u_long tx_fifo_errors;
u_long tx_heartbeat_errors;
u_long tx_window_errors;
-
+
/* for cslip etc */
u_long rx_compressed;
u_long tx_compressed;
u_int copying_receiver;
u_int carrier;
u_int maxfrags;
-
+
/* Receive-ring batched refills. */
#define RX_MIN_TARGET 32
#define RX_MAX_TARGET NET_RX_RING_SIZE
int rx_target;
grant_ref_t gref_tx_head;
- grant_ref_t grant_tx_ref[NET_TX_RING_SIZE + 1];
+ grant_ref_t grant_tx_ref[NET_TX_RING_SIZE + 1];
grant_ref_t gref_rx_head;
- grant_ref_t grant_rx_ref[NET_TX_RING_SIZE + 1];
+ grant_ref_t grant_rx_ref[NET_TX_RING_SIZE + 1];
device_t xbdev;
int tx_ring_ref;
#define XN_TX_LOCK(_sc) mtx_lock(&(_sc)->tx_lock)
#define XN_TX_UNLOCK(_sc) mtx_unlock(&(_sc)->tx_lock)
-#define XN_LOCK(_sc) mtx_lock(&(_sc)->sc_lock);
-#define XN_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_lock);
+#define XN_LOCK(_sc) mtx_lock(&(_sc)->sc_lock);
+#define XN_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_lock);
-#define XN_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->sc_lock, MA_OWNED);
-#define XN_RX_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->rx_lock, MA_OWNED);
-#define XN_TX_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->tx_lock, MA_OWNED);
+#define XN_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->sc_lock, MA_OWNED);
+#define XN_RX_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->rx_lock, MA_OWNED);
+#define XN_TX_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->tx_lock, MA_OWNED);
#define XN_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->rx_lock); \
mtx_destroy(&(_sc)->tx_lock); \
mtx_destroy(&(_sc)->sc_lock);
* a preallocated array of length ETH_ALEN (as declared in linux/if_ether.h).
* Return 0 on success, or errno on error.
*/
-static int
+static int
xen_net_read_mac(device_t dev, uint8_t mac[])
{
int error, i;
* inform the backend of the appropriate details for those. Switch to
* Connected state.
*/
-static int
+static int
netfront_probe(device_t dev)
{
static int
netfront_attach(device_t dev)
-{
+{
int err;
err = create_netdev(dev);
}
/* Common code used when first setting up, and when resuming. */
-static int
+static int
talk_to_backend(device_t dev, struct netfront_info *info)
{
const char *message;
err = setup_device(dev, info);
if (err)
goto out;
-
+
again:
err = xs_transaction_start(&xst);
if (err) {
xenbus_dev_fatal(dev, err, "completing transaction");
goto destroy_ring;
}
-
+
return 0;
-
+
abort_transaction:
xs_transaction_end(xst, 1);
xenbus_dev_fatal(dev, err, "%s", message);
return err;
}
-static int
+static int
setup_device(device_t dev, struct netfront_info *info)
{
netif_tx_sring_t *txs;
}
return (0);
-
+
fail:
netif_free(info);
return (error);
{
struct ifnet *ifp;
struct ifaddr *ifa;
-
+
ifp = info->xn_ifp;
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
if (ifa->ifa_addr->sa_family == AF_INET) {
netfront_backend_changed(device_t dev, XenbusState newstate)
{
struct netfront_info *sc = device_get_softc(dev);
-
+
DPRINTK("newstate=%d\n", newstate);
switch (newstate) {
{
#if 0
int i;
-
+
for (i = 0; i < NET_RX_RING_SIZE; i++) {
if (sc->xn_cdata.rx_mbufs[i] != NULL) {
m_freem(sc->rx_mbufs[i]);
sc->rx_mbufs[i] = NULL;
}
}
-
+
sc->rx.rsp_cons = 0;
sc->xn_rx_if->req_prod = 0;
sc->xn_rx_if->event = sc->rx.rsp_cons ;
{
#if 0
int i;
-
+
for (i = 0; i < NET_TX_RING_SIZE; i++) {
if (sc->tx_mbufs[i] != NULL) {
m_freem(sc->tx_mbufs[i]);
sc->xn_cdata.xn_tx_chain[i] = NULL;
}
}
-
+
return;
#endif
}
netif_rx_request_t *req;
vm_offset_t vaddr;
u_long pfn;
-
+
req_prod = sc->rx.req_prod_pvt;
if (__predict_false(sc->carrier == 0))
return;
-
+
/*
* Allocate mbufs greedily, even though we batch updates to the
* receive ring. This creates a less bursty demand on the memory
break;
}
m_new->m_len = m_new->m_pkthdr.len = MJUMPAGESIZE;
-
+
/* queue the mbufs allocated */
(void )mbufq_enqueue(&sc->xn_rx_batch, m_new);
}
-
+
/*
* If we've allocated at least half of our target number of entries,
* submit them to the backend - we have enough to make the overhead
* Double floating fill target if we risked having the backend
* run out of empty buffers for receive traffic. We define "running
* low" as having less than a fourth of our target buffers free
- * at the time we refilled the queue.
+ * at the time we refilled the queue.
*/
if ((req_prod - sc->rx.sring->rsp_prod) < (sc->rx_target / 4)) {
sc->rx_target *= 2;
}
req->id = id;
req->gref = ref;
-
+
sc->rx_pfn_array[i] =
vtophys(mtod(m_new,vm_offset_t)) >> PAGE_SHIFT;
- }
-
+ }
+
KASSERT(i, ("no mbufs processed")); /* should have returned earlier */
KASSERT(mbufq_len(&sc->xn_rx_batch) == 0, ("not all mbufs processed"));
/*
} else {
wmb();
}
-
+
/* Above is a suitable barrier to ensure backend will see requests. */
sc->rx.req_prod_pvt = req_prod + i;
push:
mbufq_init(&rxq, INT_MAX);
ifp = np->xn_ifp;
-
+
rp = np->rx.sring->rsp_prod;
rmb(); /* Ensure we see queued responses up to 'rp'. */
* XXX this isn't necessarily the case - need to add
* check
*/
-
+
m->m_pkthdr.csum_flags |=
(CSUM_IP_CHECKED | CSUM_IP_VALID | CSUM_DATA_VALID
| CSUM_PSEUDO_HDR);
balloon_update_driver_allowance(-pages_flipped);
#endif
}
-
+
mbufq_drain(&errq);
- /*
+ /*
* Process all the mbufs after the remapping is complete.
* Break the mbuf chain first though.
*/
while ((m = mbufq_dequeue(&rxq)) != NULL) {
if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
-
+
/*
* Do we really need to drop the rx lock?
*/
#endif
XN_RX_LOCK(np);
}
-
+
np->rx.rsp_cons = i;
#if __FreeBSD_version >= 700000 && (defined(INET) || defined(INET6))
#if 0
/* If we get a callback with very few responses, reduce fill target. */
/* NB. Note exponential increase, linear decrease. */
- if (((np->rx.req_prod_pvt - np->rx.sring->rsp_prod) >
+ if (((np->rx.req_prod_pvt - np->rx.sring->rsp_prod) >
((3*np->rx_target) / 4)) && (--np->rx_target < np->rx_min_target))
np->rx_target = np->rx_min_target;
#endif
-
+
network_alloc_rx_buffers(np);
RING_FINAL_CHECK_FOR_RESPONSES(&np->rx, work_to_do);
} while (work_to_do);
}
-static void
+static void
xn_txeof(struct netfront_info *np)
{
RING_IDX i, prod;
struct ifnet *ifp;
netif_tx_response_t *txr;
struct mbuf *m;
-
+
XN_TX_LOCK_ASSERT(np);
-
+
if (!netfront_carrier_ok(np))
return;
-
+
ifp = np->xn_ifp;
-
+
do {
prod = np->tx.sring->rsp_prod;
rmb(); /* Ensure we see responses up to 'rp'. */
-
+
for (i = np->tx.rsp_cons; i != prod; i++) {
txr = RING_GET_RESPONSE(&np->tx, i);
if (txr->status == NETIF_RSP_NULL)
__func__, txr->status);
}
id = txr->id;
- m = np->tx_mbufs[id];
+ m = np->tx_mbufs[id];
KASSERT(m != NULL, ("mbuf not found in xn_tx_chain"));
KASSERT((uintptr_t)m > NET_TX_RING_SIZE,
("mbuf already on the free list, but we're "
"trying to free it again!"));
M_ASSERTVALID(m);
-
+
/*
* Increment packet count if this is the last
* mbuf of the chain.
gnttab_release_grant_reference(
&np->gref_tx_head, np->grant_tx_ref[id]);
np->grant_tx_ref[id] = GRANT_REF_INVALID;
-
+
np->tx_mbufs[id] = NULL;
add_id_to_freelist(np->tx_mbufs, id);
np->xn_cdata.xn_tx_chain_cnt--;
ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
}
np->tx.rsp_cons = prod;
-
+
/*
* Set a new event, then check for race with update of
* tx_cons. Note that it is essential to schedule a
mb();
} while (prod != np->tx.sring->rsp_prod);
-
+
if (np->tx_full &&
((np->tx.sring->req_prod - prod) < NET_TX_RING_SIZE)) {
np->tx_full = 0;
if (RING_HAS_UNCONSUMED_RESPONSES(&np->tx)) {
XN_TX_LOCK(np);
xn_txeof(np);
- XN_TX_UNLOCK(np);
- }
+ XN_TX_UNLOCK(np);
+ }
XN_RX_LOCK(np);
xn_rxeof(np);
grant_ref_t ref;
if (__predict_false(*cons + 1 == rp)) {
-#if 0
+#if 0
if (net_ratelimit())
WPRINTK("Missing extra info\n");
-#endif
+#endif
err = EINVAL;
break;
}
if (__predict_false(!extra->type ||
extra->type >= XEN_NETIF_EXTRA_TYPE_MAX)) {
-#if 0
+#if 0
if (net_ratelimit())
WPRINTK("Invalid extra type: %d\n",
extra->type);
-#endif
+#endif
err = EINVAL;
} else {
memcpy(&extras[extra->type - 1], extra, sizeof(*extra));
for (;;) {
u_long mfn;
-#if 0
+#if 0
DPRINTK("rx->status=%hd rx->offset=%hu frags=%u\n",
rx->status, rx->offset, frags);
#endif
if (__predict_false(rx->status < 0 ||
rx->offset + rx->status > PAGE_SIZE)) {
-#if 0
+#if 0
if (net_ratelimit())
WPRINTK("rx->offset: %x, size: %u\n",
rx->offset, rx->status);
-#endif
+#endif
xennet_move_rx_slot(np, m, ref);
if (m0 == m)
m0 = NULL;
err = EINVAL;
goto next_skip_queue;
}
-
+
/*
* This definitely indicates a bug, either in this driver or in
* the backend driver. In future this should flag the bad
*/
if (ref == GRANT_REF_INVALID) {
-#if 0
+#if 0
if (net_ratelimit())
WPRINTK("Bad rx response id %d.\n", rx->id);
-#endif
+#endif
printf("%s: Bad rx response id %d.\n", __func__,rx->id);
err = EINVAL;
goto next;
m->m_len = rx->status;
m->m_data += rx->offset;
m0->m_pkthdr.len += rx->status;
-
+
next_skip_queue:
if (!(rx->flags & NETRXF_more_data))
break;
}
/*
* Note that m can be NULL, if rx->status < 0 or if
- * rx->offset + rx->status > PAGE_SIZE above.
+ * rx->offset + rx->status > PAGE_SIZE above.
*/
m_prev = m;
-
+
rx = RING_GET_RESPONSE(&np->rx, *cons + frags);
m = xennet_get_rx_mbuf(np, *cons + frags);
/*
* m_prev == NULL can happen if rx->status < 0 or if
- * rx->offset + * rx->status > PAGE_SIZE above.
+ * rx->offset + * rx->status > PAGE_SIZE above.
*/
if (m_prev != NULL)
m_prev->m_next = m;
/*
* m0 can be NULL if rx->status < 0 or if * rx->offset +
- * rx->status > PAGE_SIZE above.
+ * rx->status > PAGE_SIZE above.
*/
if (m0 == NULL)
m0 = m;
}
static void
-xn_tick_locked(struct netfront_info *sc)
+xn_tick_locked(struct netfront_info *sc)
{
XN_RX_LOCK_ASSERT(sc);
callout_reset(&sc->xn_stat_ch, hz, xn_tick, sc);
}
static void
-xn_tick(void *xsc)
+xn_tick(void *xsc)
{
struct netfront_info *sc;
-
+
sc = xsc;
XN_RX_LOCK(sc);
xn_tick_locked(sc);
}
static void
-xn_start_locked(struct ifnet *ifp)
+xn_start_locked(struct ifnet *ifp)
{
struct netfront_info *sc;
struct mbuf *m_head;
}
/* equivalent of network_open() in Linux */
-static void
-xn_ifinit_locked(struct netfront_info *sc)
+static void
+xn_ifinit_locked(struct netfront_info *sc)
{
struct ifnet *ifp;
-
+
XN_LOCK_ASSERT(sc);
-
+
ifp = sc->xn_ifp;
-
- if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+
+ if (ifp->if_drv_flags & IFF_DRV_RUNNING)
return;
-
+
xn_stop(sc);
-
+
network_alloc_rx_buffers(sc);
sc->rx.sring->rsp_event = sc->rx.rsp_cons + 1;
-
+
ifp->if_drv_flags |= IFF_DRV_RUNNING;
ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
if_link_state_change(ifp, LINK_STATE_UP);
-
+
callout_reset(&sc->xn_stat_ch, hz, xn_tick, sc);
}
-static void
+static void
xn_ifinit(void *xsc)
{
struct netfront_info *sc = xsc;
-
+
XN_LOCK(sc);
xn_ifinit_locked(sc);
XN_UNLOCK(sc);
XN_LOCK(sc);
if (ifa->ifa_addr->sa_family == AF_INET) {
ifp->if_flags |= IFF_UP;
- if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+ if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
xn_ifinit_locked(sc);
arp_ifinit(ifp, ifa);
- XN_UNLOCK(sc);
+ XN_UNLOCK(sc);
} else {
- XN_UNLOCK(sc);
+ XN_UNLOCK(sc);
#endif
error = ether_ioctl(ifp, cmd, data);
#ifdef INET
#ifdef notyet
if (ifr->ifr_mtu > XN_JUMBO_MTU)
error = EINVAL;
- else
+ else
#endif
{
ifp->if_mtu = ifr->ifr_mtu;
}
if (mask & IFCAP_LRO) {
ifp->if_capenable ^= IFCAP_LRO;
-
+
}
#endif
error = 0;
default:
error = ether_ioctl(ifp, cmd, data);
}
-
+
return (error);
}
static void
xn_stop(struct netfront_info *sc)
-{
+{
struct ifnet *ifp;
XN_LOCK_ASSERT(sc);
-
+
ifp = sc->xn_ifp;
callout_stop(&sc->xn_stat_ch);
xn_free_rx_ring(sc);
xn_free_tx_ring(sc);
-
+
ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
if_link_state_change(ifp, LINK_STATE_DOWN);
}
/* Recovery procedure: */
error = talk_to_backend(np->xbdev, np);
- if (error)
+ if (error)
return (error);
-
+
/* Step 1: Reinitialise variables. */
xn_query_features(np);
xn_configure_features(np);
}
np->rx.req_prod_pvt = requeue_idx;
-
+
/* Step 3: All public and private state should now be sane. Get
* ready to start sending and receiving packets and give the driver
* domain a kick because we've probably just requeued some
* Create a network device.
* @param dev Newbus device representing this virtual NIC.
*/
-int
+int
create_netdev(device_t dev)
{
int i;
struct ifnet *ifp;
np = device_get_softc(dev);
-
+
np->xbdev = dev;
-
+
XN_LOCK_INIT(np, xennetif);
ifmedia_init(&np->sc_media, 0, xn_ifmedia_upd, xn_ifmedia_sts);
/* Initialise {tx,rx}_skbs to be a free chain containing every entry. */
for (i = 0; i <= NET_TX_RING_SIZE; i++) {
np->tx_mbufs[i] = (void *) ((u_long) i+1);
- np->grant_tx_ref[i] = GRANT_REF_INVALID;
+ np->grant_tx_ref[i] = GRANT_REF_INVALID;
}
np->tx_mbufs[NET_TX_RING_SIZE] = (void *)0;
err = ENOMEM;
goto exit;
}
-
+
err = xen_net_read_mac(dev, np->mac);
if (err)
goto out;
-
+
/* Set up ifnet structure */
ifp = np->xn_ifp = if_alloc(IFT_ETHER);
ifp->if_softc = np;
#endif
ifp->if_init = xn_ifinit;
ifp->if_snd.ifq_maxlen = NET_TX_RING_SIZE - 1;
-
+
ifp->if_hwassist = XN_CSUM_FEATURES;
ifp->if_capabilities = IFCAP_HWCSUM;
ifp->if_hw_tsomax = 65536 - (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN);
ifp->if_hw_tsomaxsegcount = MAX_TX_REQ_FRAGS;
ifp->if_hw_tsomaxsegsize = PAGE_SIZE;
-
+
ether_ifattach(ifp, np->mac);
callout_init(&np->xn_stat_ch, 1);
netfront_carrier_off(np);
}
/* ** Driver registration ** */
-static device_method_t netfront_methods[] = {
- /* Device interface */
- DEVMETHOD(device_probe, netfront_probe),
- DEVMETHOD(device_attach, netfront_attach),
- DEVMETHOD(device_detach, netfront_detach),
- DEVMETHOD(device_shutdown, bus_generic_shutdown),
- DEVMETHOD(device_suspend, netfront_suspend),
- DEVMETHOD(device_resume, netfront_resume),
-
+static device_method_t netfront_methods[] = {
+ /* Device interface */
+ DEVMETHOD(device_probe, netfront_probe),
+ DEVMETHOD(device_attach, netfront_attach),
+ DEVMETHOD(device_detach, netfront_detach),
+ DEVMETHOD(device_shutdown, bus_generic_shutdown),
+ DEVMETHOD(device_suspend, netfront_suspend),
+ DEVMETHOD(device_resume, netfront_resume),
+
/* Xenbus interface */
DEVMETHOD(xenbus_otherend_changed, netfront_backend_changed),
DEVMETHOD_END
-};
-
-static driver_t netfront_driver = {
- "xn",
- netfront_methods,
- sizeof(struct netfront_info),
-};
-devclass_t netfront_devclass;
-
+};
+
+static driver_t netfront_driver = {
+ "xn",
+ netfront_methods,
+ sizeof(struct netfront_info),
+};
+devclass_t netfront_devclass;
+
DRIVER_MODULE(xe, xenbusb_front, netfront_driver, netfront_devclass, NULL,
- NULL);
+ NULL);
projects / people / julieng / freebsd.git / commitdiff