d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
074cfd048f
freebsd-skq/sys/dev/xen/netback/netback.c
rrs 2688c69180 Adds support for SCTP checksum offload. This means 
we, like TCP and UDP, move the checksum calculation
into the IP routines when there is no hardware support
we call into the normal SCTP checksum routine.

The next round of SCTP updates will use
this functionality. Of course the IGB driver needs
a few updates to support the new intel controller set
that actually does SCTP csum offload too.

Reviewed by:	gnn, rwatson, kmacy
2009-02-03 11:00:43 +00:00

1597 lines
39 KiB
C
Raw Blame History

/*
* Copyright (c) 2006, Cisco Systems, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Cisco Systems, Inc. nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_sctp.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/sockio.h>
#include <sys/mbuf.h>
#include <sys/malloc.h>
#include <sys/kernel.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <sys/taskqueue.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <net/if_types.h>
#include <net/ethernet.h>
#include <net/if_bridgevar.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>
#ifdef SCTP
#include <netinet/sctp.h>
#include <netinet/sctp_crc32.h>
#endif
#include <vm/vm_extern.h>
#include <vm/vm_kern.h>
#include <machine/in_cksum.h>
#include <machine/xen-os.h>
#include <machine/hypervisor.h>
#include <machine/hypervisor-ifs.h>
#include <machine/xen_intr.h>
#include <machine/evtchn.h>
#include <machine/xenbus.h>
#include <machine/gnttab.h>
#include <machine/xen-public/memory.h>
#include <dev/xen/xenbus/xenbus_comms.h>
#ifdef XEN_NETBACK_DEBUG
#define DPRINTF(fmt, args...) \
printf("netback (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args)
#else
#define DPRINTF(fmt, args...) ((void)0)
#endif
#ifdef XEN_NETBACK_DEBUG_LOTS
#define DDPRINTF(fmt, args...) \
printf("netback (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args)
#define DPRINTF_MBUF(_m) print_mbuf(_m, 0)
#define DPRINTF_MBUF_LEN(_m, _len) print_mbuf(_m, _len)
#else
#define DDPRINTF(fmt, args...) ((void)0)
#define DPRINTF_MBUF(_m) ((void)0)
#define DPRINTF_MBUF_LEN(_m, _len) ((void)0)
#endif
#define WPRINTF(fmt, args...) \
printf("netback (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args)
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
#define BUG_ON PANIC_IF
#define IFNAME(_np) (_np)->ifp->if_xname
#define NET_TX_RING_SIZE __RING_SIZE((netif_tx_sring_t *)0, PAGE_SIZE)
#define NET_RX_RING_SIZE __RING_SIZE((netif_rx_sring_t *)0, PAGE_SIZE)
struct ring_ref {
vm_offset_t va;
grant_handle_t handle;
uint64_t bus_addr;
};
typedef struct netback_info {
/* Schedule lists */
STAILQ_ENTRY(netback_info) next_tx;
STAILQ_ENTRY(netback_info) next_rx;
int on_tx_sched_list;
int on_rx_sched_list;
struct xenbus_device *xdev;
XenbusState frontend_state;
domid_t domid;
int handle;
char *bridge;
int rings_connected;
struct ring_ref tx_ring_ref;
struct ring_ref rx_ring_ref;
netif_tx_back_ring_t tx;
netif_rx_back_ring_t rx;
evtchn_port_t evtchn;
int irq;
void *irq_cookie;
struct ifnet *ifp;
int ref_cnt;
device_t ndev;
int attached;
} netif_t;
#define MAX_PENDING_REQS 256
#define PKT_PROT_LEN 64
static struct {
netif_tx_request_t req;
netif_t *netif;
} pending_tx_info[MAX_PENDING_REQS];
static uint16_t pending_ring[MAX_PENDING_REQS];
typedef unsigned int PEND_RING_IDX;
#define MASK_PEND_IDX(_i) ((_i)&(MAX_PENDING_REQS-1))
static PEND_RING_IDX pending_prod, pending_cons;
#define NR_PENDING_REQS (MAX_PENDING_REQS - pending_prod + pending_cons)
static unsigned long mmap_vstart;
#define MMAP_VADDR(_req) (mmap_vstart + ((_req) * PAGE_SIZE))
/* Freed TX mbufs get batched on this ring before return to pending_ring. */
static uint16_t dealloc_ring[MAX_PENDING_REQS];
static PEND_RING_IDX dealloc_prod, dealloc_cons;
static multicall_entry_t rx_mcl[NET_RX_RING_SIZE+1];
static mmu_update_t rx_mmu[NET_RX_RING_SIZE];
static gnttab_transfer_t grant_rx_op[NET_RX_RING_SIZE];
static grant_handle_t grant_tx_handle[MAX_PENDING_REQS];
static gnttab_unmap_grant_ref_t tx_unmap_ops[MAX_PENDING_REQS];
static gnttab_map_grant_ref_t tx_map_ops[MAX_PENDING_REQS];
static struct task net_tx_task, net_rx_task;
static struct callout rx_task_callout;
static STAILQ_HEAD(netback_tx_sched_list, netback_info) tx_sched_list =
STAILQ_HEAD_INITIALIZER(tx_sched_list);
static STAILQ_HEAD(netback_rx_sched_list, netback_info) rx_sched_list =
STAILQ_HEAD_INITIALIZER(rx_sched_list);
static struct mtx tx_sched_list_lock;
static struct mtx rx_sched_list_lock;
static int vif_unit_maker = 0;
/* Protos */
static void netback_start(struct ifnet *ifp);
static int netback_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
static int vif_add_dev(struct xenbus_device *xdev);
static void disconnect_rings(netif_t *netif);
#ifdef XEN_NETBACK_DEBUG_LOTS
/* Debug code to display the contents of an mbuf */
static void
print_mbuf(struct mbuf *m, int max)
{
int i, j=0;
printf("mbuf %08x len = %d", (unsigned int)m, m->m_pkthdr.len);
for (; m; m = m->m_next) {
unsigned char *d = m->m_data;
for (i=0; i < m->m_len; i++) {
if (max && j == max)
break;
if ((j++ % 16) == 0)
printf("\n%04x:", j);
printf(" %02x", d[i]);
}
}
printf("\n");
}
#endif
#define MAX_MFN_ALLOC 64
static unsigned long mfn_list[MAX_MFN_ALLOC];
static unsigned int alloc_index = 0;
static unsigned long
alloc_mfn(void)
{
unsigned long mfn = 0;
struct xen_memory_reservation reservation = {
.extent_start = mfn_list,
.nr_extents = MAX_MFN_ALLOC,
.extent_order = 0,
.domid = DOMID_SELF
};
if ( unlikely(alloc_index == 0) )
alloc_index = HYPERVISOR_memory_op(
XENMEM_increase_reservation, &reservation);
if ( alloc_index != 0 )
mfn = mfn_list[--alloc_index];
return mfn;
}
static unsigned long
alloc_empty_page_range(unsigned long nr_pages)
{
void *pages;
int i = 0, j = 0;
multicall_entry_t mcl[17];
unsigned long mfn_list[16];
struct xen_memory_reservation reservation = {
.extent_start = mfn_list,
.nr_extents = 0,
.address_bits = 0,
.extent_order = 0,
.domid = DOMID_SELF
};
pages = malloc(nr_pages*PAGE_SIZE, M_DEVBUF, M_NOWAIT);
if (pages == NULL)
return 0;
memset(mcl, 0, sizeof(mcl));
while (i < nr_pages) {
unsigned long va = (unsigned long)pages + (i++ * PAGE_SIZE);
mcl[j].op = __HYPERVISOR_update_va_mapping;
mcl[j].args[0] = va;
mfn_list[j++] = vtomach(va) >> PAGE_SHIFT;
xen_phys_machine[(vtophys(va) >> PAGE_SHIFT)] = INVALID_P2M_ENTRY;
if (j == 16 || i == nr_pages) {
mcl[j-1].args[MULTI_UVMFLAGS_INDEX] = UVMF_TLB_FLUSH|UVMF_LOCAL;
reservation.nr_extents = j;
mcl[j].op = __HYPERVISOR_memory_op;
mcl[j].args[0] = XENMEM_decrease_reservation;
mcl[j].args[1] = (unsigned long)&reservation;
(void)HYPERVISOR_multicall(mcl, j+1);
mcl[j-1].args[MULTI_UVMFLAGS_INDEX] = 0;
j = 0;
}
}
return (unsigned long)pages;
}
#ifdef XEN_NETBACK_FIXUP_CSUM
static void
fixup_checksum(struct mbuf *m)
{
struct ether_header *eh = mtod(m, struct ether_header *);
struct ip *ip = (struct ip *)(eh + 1);
int iphlen = ip->ip_hl << 2;
int iplen = ntohs(ip->ip_len);
if ((m->m_pkthdr.csum_flags & CSUM_TCP)) {
struct tcphdr *th = (struct tcphdr *)((caddr_t)ip + iphlen);
th->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
htons(IPPROTO_TCP + (iplen - iphlen)));
th->th_sum = in_cksum_skip(m, iplen + sizeof(*eh), sizeof(*eh) + iphlen);
m->m_pkthdr.csum_flags &= ~CSUM_TCP;
#ifdef SCTP
} else if (sw_csum & CSUM_SCTP) {
sctp_delayed_cksum(m);
sw_csum &= ~CSUM_SCTP;
#endif
} else {
u_short csum;
struct udphdr *uh = (struct udphdr *)((caddr_t)ip + iphlen);
uh->uh_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
htons(IPPROTO_UDP + (iplen - iphlen)));
if ((csum = in_cksum_skip(m, iplen + sizeof(*eh), sizeof(*eh) + iphlen)) == 0)
csum = 0xffff;
uh->uh_sum = csum;
m->m_pkthdr.csum_flags &= ~CSUM_UDP;
}
}
#endif
/* Add the interface to the specified bridge */
static int
add_to_bridge(struct ifnet *ifp, char *bridge)
{
struct ifdrv ifd;
struct ifbreq ifb;
struct ifnet *ifp_bridge = ifunit(bridge);
if (!ifp_bridge)
return ENOENT;
bzero(&ifd, sizeof(ifd));
bzero(&ifb, sizeof(ifb));
strcpy(ifb.ifbr_ifsname, ifp->if_xname);
strcpy(ifd.ifd_name, ifp->if_xname);
ifd.ifd_cmd = BRDGADD;
ifd.ifd_len = sizeof(ifb);
ifd.ifd_data = &ifb;
return bridge_ioctl_kern(ifp_bridge, SIOCSDRVSPEC, &ifd);
}
static int
netif_create(int handle, struct xenbus_device *xdev, char *bridge)
{
netif_t *netif;
struct ifnet *ifp;
netif = (netif_t *)malloc(sizeof(*netif), M_DEVBUF, M_NOWAIT | M_ZERO);
if (!netif)
return ENOMEM;
netif->ref_cnt = 1;
netif->handle = handle;
netif->domid = xdev->otherend_id;
netif->xdev = xdev;
netif->bridge = bridge;
xdev->data = netif;
/* Set up ifnet structure */
ifp = netif->ifp = if_alloc(IFT_ETHER);
if (!ifp) {
if (bridge)
free(bridge, M_DEVBUF);
free(netif, M_DEVBUF);
return ENOMEM;
}
ifp->if_softc = netif;
if_initname(ifp, "vif",
atomic_fetchadd_int(&vif_unit_maker, 1) /* ifno */ );
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
ifp->if_output = ether_output;
ifp->if_start = netback_start;
ifp->if_ioctl = netback_ioctl;
ifp->if_mtu = ETHERMTU;
ifp->if_snd.ifq_maxlen = NET_TX_RING_SIZE - 1;
DPRINTF("Created %s for domid=%d handle=%d\n", IFNAME(netif), netif->domid, netif->handle);
return 0;
}
static void
netif_get(netif_t *netif)
{
atomic_add_int(&netif->ref_cnt, 1);
}
static void
netif_put(netif_t *netif)
{
if (atomic_fetchadd_int(&netif->ref_cnt, -1) == 1) {
DPRINTF("%s\n", IFNAME(netif));
disconnect_rings(netif);
if (netif->ifp) {
if_free(netif->ifp);
netif->ifp = NULL;
}
if (netif->bridge)
free(netif->bridge, M_DEVBUF);
free(netif, M_DEVBUF);
}
}
static int
netback_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
{
switch (cmd) {
case SIOCSIFFLAGS:
DDPRINTF("%s cmd=SIOCSIFFLAGS flags=%x\n",
IFNAME((struct netback_info *)ifp->if_softc), ((struct ifreq *)data)->ifr_flags);
return 0;
}
DDPRINTF("%s cmd=%lx\n", IFNAME((struct netback_info *)ifp->if_softc), cmd);
return ether_ioctl(ifp, cmd, data);
}
static inline void
maybe_schedule_tx_action(void)
{
smp_mb();
if ((NR_PENDING_REQS < (MAX_PENDING_REQS/2)) && !STAILQ_EMPTY(&tx_sched_list))
taskqueue_enqueue(taskqueue_swi, &net_tx_task);
}
/* Removes netif from front of list and does not call netif_put() (caller must) */
static netif_t *
remove_from_tx_schedule_list(void)
{
netif_t *netif;
mtx_lock(&tx_sched_list_lock);
if ((netif = STAILQ_FIRST(&tx_sched_list))) {
STAILQ_REMOVE(&tx_sched_list, netif, netback_info, next_tx);
STAILQ_NEXT(netif, next_tx) = NULL;
netif->on_tx_sched_list = 0;
}
mtx_unlock(&tx_sched_list_lock);
return netif;
}
/* Adds netif to end of list and calls netif_get() */
static void
add_to_tx_schedule_list_tail(netif_t *netif)
{
if (netif->on_tx_sched_list)
return;
mtx_lock(&tx_sched_list_lock);
if (!netif->on_tx_sched_list && (netif->ifp->if_drv_flags & IFF_DRV_RUNNING)) {
netif_get(netif);
STAILQ_INSERT_TAIL(&tx_sched_list, netif, next_tx);
netif->on_tx_sched_list = 1;
}
mtx_unlock(&tx_sched_list_lock);
}
/*
* Note on CONFIG_XEN_NETDEV_PIPELINED_TRANSMITTER:
* If this driver is pipelining transmit requests then we can be very
* aggressive in avoiding new-packet notifications -- frontend only needs to
* send a notification if there are no outstanding unreceived responses.
* If we may be buffer transmit buffers for any reason then we must be rather
* more conservative and treat this as the final check for pending work.
*/
static void
netif_schedule_tx_work(netif_t *netif)
{
int more_to_do;
#ifdef CONFIG_XEN_NETDEV_PIPELINED_TRANSMITTER
more_to_do = RING_HAS_UNCONSUMED_REQUESTS(&netif->tx);
#else
RING_FINAL_CHECK_FOR_REQUESTS(&netif->tx, more_to_do);
#endif
if (more_to_do) {
DDPRINTF("Adding %s to tx sched list\n", IFNAME(netif));
add_to_tx_schedule_list_tail(netif);
maybe_schedule_tx_action();
}
}
static struct mtx dealloc_lock;
MTX_SYSINIT(netback_dealloc, &dealloc_lock, "DEALLOC LOCK", MTX_SPIN | MTX_NOWITNESS);
static void
netif_idx_release(uint16_t pending_idx)
{
mtx_lock_spin(&dealloc_lock);
dealloc_ring[MASK_PEND_IDX(dealloc_prod++)] = pending_idx;
mtx_unlock_spin(&dealloc_lock);
taskqueue_enqueue(taskqueue_swi, &net_tx_task);
}
static void
make_tx_response(netif_t *netif,
uint16_t id,
int8_t st)
{
RING_IDX i = netif->tx.rsp_prod_pvt;
netif_tx_response_t *resp;
int notify;
resp = RING_GET_RESPONSE(&netif->tx, i);
resp->id = id;
resp->status = st;
netif->tx.rsp_prod_pvt = ++i;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netif->tx, notify);
if (notify)
notify_remote_via_irq(netif->irq);
#ifdef CONFIG_XEN_NETDEV_PIPELINED_TRANSMITTER
if (i == netif->tx.req_cons) {
int more_to_do;
RING_FINAL_CHECK_FOR_REQUESTS(&netif->tx, more_to_do);
if (more_to_do)
add_to_tx_schedule_list_tail(netif);
}
#endif
}
inline static void
net_tx_action_dealloc(void)
{
gnttab_unmap_grant_ref_t *gop;
uint16_t pending_idx;
PEND_RING_IDX dc, dp;
netif_t *netif;
int ret;
dc = dealloc_cons;
dp = dealloc_prod;
/*
* Free up any grants we have finished using
*/
gop = tx_unmap_ops;
while (dc != dp) {
pending_idx = dealloc_ring[MASK_PEND_IDX(dc++)];
gop->host_addr = MMAP_VADDR(pending_idx);
gop->dev_bus_addr = 0;
gop->handle = grant_tx_handle[pending_idx];
gop++;
}
ret = HYPERVISOR_grant_table_op(
GNTTABOP_unmap_grant_ref, tx_unmap_ops, gop - tx_unmap_ops);
BUG_ON(ret);
while (dealloc_cons != dp) {
pending_idx = dealloc_ring[MASK_PEND_IDX(dealloc_cons++)];
netif = pending_tx_info[pending_idx].netif;
make_tx_response(netif, pending_tx_info[pending_idx].req.id,
NETIF_RSP_OKAY);
pending_ring[MASK_PEND_IDX(pending_prod++)] = pending_idx;
netif_put(netif);
}
}
static void
netif_page_release(void *buf, void *args)
{
uint16_t pending_idx = (unsigned int)args;
DDPRINTF("pending_idx=%u\n", pending_idx);
KASSERT(pending_idx < MAX_PENDING_REQS, ("%s: bad index %u", __func__, pending_idx));
netif_idx_release(pending_idx);
}
static void
net_tx_action(void *context, int pending)
{
struct mbuf *m;
netif_t *netif;
netif_tx_request_t txreq;
uint16_t pending_idx;
RING_IDX i;
gnttab_map_grant_ref_t *mop;
int ret, work_to_do;
struct mbuf *txq = NULL, *txq_last = NULL;
if (dealloc_cons != dealloc_prod)
net_tx_action_dealloc();
mop = tx_map_ops;
while ((NR_PENDING_REQS < MAX_PENDING_REQS) && !STAILQ_EMPTY(&tx_sched_list)) {
/* Get a netif from the list with work to do. */
netif = remove_from_tx_schedule_list();
DDPRINTF("Processing %s (prod=%u, cons=%u)\n",
IFNAME(netif), netif->tx.sring->req_prod, netif->tx.req_cons);
RING_FINAL_CHECK_FOR_REQUESTS(&netif->tx, work_to_do);
if (!work_to_do) {
netif_put(netif);
continue;
}
i = netif->tx.req_cons;
rmb(); /* Ensure that we see the request before we copy it. */
memcpy(&txreq, RING_GET_REQUEST(&netif->tx, i), sizeof(txreq));
/* If we want credit-based scheduling, coud add it here - WORK */
netif->tx.req_cons++;
netif_schedule_tx_work(netif);
if (unlikely(txreq.size < ETHER_HDR_LEN) ||
unlikely(txreq.size > (ETHER_MAX_LEN-ETHER_CRC_LEN))) {
WPRINTF("Bad packet size: %d\n", txreq.size);
make_tx_response(netif, txreq.id, NETIF_RSP_ERROR);
netif_put(netif);
continue;
}
/* No crossing a page as the payload mustn't fragment. */
if (unlikely((txreq.offset + txreq.size) >= PAGE_SIZE)) {
WPRINTF("txreq.offset: %x, size: %u, end: %u\n",
txreq.offset, txreq.size,
(txreq.offset & PAGE_MASK) + txreq.size);
make_tx_response(netif, txreq.id, NETIF_RSP_ERROR);
netif_put(netif);
continue;
}
pending_idx = pending_ring[MASK_PEND_IDX(pending_cons)];
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (!m) {
WPRINTF("Failed to allocate mbuf\n");
make_tx_response(netif, txreq.id, NETIF_RSP_ERROR);
netif_put(netif);
break;
}
m->m_pkthdr.rcvif = netif->ifp;
if ((m->m_pkthdr.len = txreq.size) > PKT_PROT_LEN) {
struct mbuf *n;
MGET(n, M_DONTWAIT, MT_DATA);
if (!(m->m_next = n)) {
m_freem(m);
WPRINTF("Failed to allocate second mbuf\n");
make_tx_response(netif, txreq.id, NETIF_RSP_ERROR);
netif_put(netif);
break;
}
n->m_len = txreq.size - PKT_PROT_LEN;
m->m_len = PKT_PROT_LEN;
} else
m->m_len = txreq.size;
mop->host_addr = MMAP_VADDR(pending_idx);
mop->dom = netif->domid;
mop->ref = txreq.gref;
mop->flags = GNTMAP_host_map | GNTMAP_readonly;
mop++;
memcpy(&pending_tx_info[pending_idx].req,
&txreq, sizeof(txreq));
pending_tx_info[pending_idx].netif = netif;
*((uint16_t *)m->m_data) = pending_idx;
if (txq_last)
txq_last->m_nextpkt = m;
else
txq = m;
txq_last = m;
pending_cons++;
if ((mop - tx_map_ops) >= ARRAY_SIZE(tx_map_ops))
break;
}
if (!txq)
return;
ret = HYPERVISOR_grant_table_op(
GNTTABOP_map_grant_ref, tx_map_ops, mop - tx_map_ops);
BUG_ON(ret);
mop = tx_map_ops;
while ((m = txq) != NULL) {
caddr_t data;
txq = m->m_nextpkt;
m->m_nextpkt = NULL;
pending_idx = *((uint16_t *)m->m_data);
netif = pending_tx_info[pending_idx].netif;
memcpy(&txreq, &pending_tx_info[pending_idx].req, sizeof(txreq));
/* Check the remap error code. */
if (unlikely(mop->status)) {
WPRINTF("#### netback grant fails\n");
make_tx_response(netif, txreq.id, NETIF_RSP_ERROR);
netif_put(netif);
m_freem(m);
mop++;
pending_ring[MASK_PEND_IDX(pending_prod++)] = pending_idx;
continue;
}
#if 0
/* Can't do this in FreeBSD since vtophys() returns the pfn */
/* of the remote domain who loaned us the machine page - DPT */
xen_phys_machine[(vtophys(MMAP_VADDR(pending_idx)) >> PAGE_SHIFT)] =
mop->dev_bus_addr >> PAGE_SHIFT;
#endif
grant_tx_handle[pending_idx] = mop->handle;
/* Setup data in mbuf (lengths are already set) */
data = (caddr_t)(MMAP_VADDR(pending_idx)|txreq.offset);
bcopy(data, m->m_data, m->m_len);
if (m->m_next) {
struct mbuf *n = m->m_next;
MEXTADD(n, MMAP_VADDR(pending_idx), PAGE_SIZE, netif_page_release,
(void *)(unsigned int)pending_idx, M_RDONLY, EXT_NET_DRV);
n->m_data = &data[PKT_PROT_LEN];
} else {
/* Schedule a response immediately. */
netif_idx_release(pending_idx);
}
if ((txreq.flags & NETTXF_data_validated)) {
/* Tell the stack the checksums are okay */
m->m_pkthdr.csum_flags |=
(CSUM_IP_CHECKED | CSUM_IP_VALID | CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
m->m_pkthdr.csum_data = 0xffff;
}
/* If necessary, inform stack to compute the checksums if it forwards the packet */
if ((txreq.flags & NETTXF_csum_blank)) {
struct ether_header *eh = mtod(m, struct ether_header *);
if (ntohs(eh->ether_type) == ETHERTYPE_IP) {
struct ip *ip = (struct ip *)&m->m_data[14];
if (ip->ip_p == IPPROTO_TCP)
m->m_pkthdr.csum_flags |= CSUM_TCP;
else if (ip->ip_p == IPPROTO_UDP)
m->m_pkthdr.csum_flags |= CSUM_UDP;
}
}
netif->ifp->if_ibytes += m->m_pkthdr.len;
netif->ifp->if_ipackets++;
DDPRINTF("RECV %d bytes from %s (cflags=%x)\n",
m->m_pkthdr.len, IFNAME(netif), m->m_pkthdr.csum_flags);
DPRINTF_MBUF_LEN(m, 128);
(*netif->ifp->if_input)(netif->ifp, m);
mop++;
}
}
/* Handle interrupt from a frontend */
static void
netback_intr(void *arg)
{
netif_t *netif = arg;
DDPRINTF("%s\n", IFNAME(netif));
add_to_tx_schedule_list_tail(netif);
maybe_schedule_tx_action();
}
/* Removes netif from front of list and does not call netif_put() (caller must) */
static netif_t *
remove_from_rx_schedule_list(void)
{
netif_t *netif;
mtx_lock(&rx_sched_list_lock);
if ((netif = STAILQ_FIRST(&rx_sched_list))) {
STAILQ_REMOVE(&rx_sched_list, netif, netback_info, next_rx);
STAILQ_NEXT(netif, next_rx) = NULL;
netif->on_rx_sched_list = 0;
}
mtx_unlock(&rx_sched_list_lock);
return netif;
}
/* Adds netif to end of list and calls netif_get() */
static void
add_to_rx_schedule_list_tail(netif_t *netif)
{
if (netif->on_rx_sched_list)
return;
mtx_lock(&rx_sched_list_lock);
if (!netif->on_rx_sched_list && (netif->ifp->if_drv_flags & IFF_DRV_RUNNING)) {
netif_get(netif);
STAILQ_INSERT_TAIL(&rx_sched_list, netif, next_rx);
netif->on_rx_sched_list = 1;
}
mtx_unlock(&rx_sched_list_lock);
}
static int
make_rx_response(netif_t *netif, uint16_t id, int8_t st,
uint16_t offset, uint16_t size, uint16_t flags)
{
RING_IDX i = netif->rx.rsp_prod_pvt;
netif_rx_response_t *resp;
int notify;
resp = RING_GET_RESPONSE(&netif->rx, i);
resp->offset = offset;
resp->flags = flags;
resp->id = id;
resp->status = (int16_t)size;
if (st < 0)
resp->status = (int16_t)st;
DDPRINTF("rx resp(%d): off=%x fl=%x id=%x stat=%d\n",
i, resp->offset, resp->flags, resp->id, resp->status);
netif->rx.rsp_prod_pvt = ++i;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netif->rx, notify);
return notify;
}
static int
netif_rx(netif_t *netif)
{
struct ifnet *ifp = netif->ifp;
struct mbuf *m;
multicall_entry_t *mcl;
mmu_update_t *mmu;
gnttab_transfer_t *gop;
unsigned long vdata, old_mfn, new_mfn;
struct mbuf *rxq = NULL, *rxq_last = NULL;
int ret, notify = 0, pkts_dequeued = 0;
DDPRINTF("%s\n", IFNAME(netif));
mcl = rx_mcl;
mmu = rx_mmu;
gop = grant_rx_op;
while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
/* Quit if the target domain has no receive buffers */
if (netif->rx.req_cons == netif->rx.sring->req_prod)
break;
IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
if (m == NULL)
break;
pkts_dequeued++;
/* Check if we need to copy the data */
if (((m->m_flags & (M_RDONLY|M_EXT)) != M_EXT) ||
(*m->m_ext.ref_cnt > 1) || m->m_next != NULL) {
struct mbuf *n;
DDPRINTF("copying mbuf (fl=%x ext=%x rc=%d n=%x)\n",
m->m_flags,
(m->m_flags & M_EXT) ? m->m_ext.ext_type : 0,
(m->m_flags & M_EXT) ? *m->m_ext.ref_cnt : 0,
(unsigned int)m->m_next);
/* Make copy */
MGETHDR(n, M_DONTWAIT, MT_DATA);
if (!n)
goto drop;
MCLGET(n, M_DONTWAIT);
if (!(n->m_flags & M_EXT)) {
m_freem(n);
goto drop;
}
/* Leave space at front and keep current alignment */
n->m_data += 16 + ((unsigned int)m->m_data & 0x3);
if (m->m_pkthdr.len > M_TRAILINGSPACE(n)) {
WPRINTF("pkt to big %d\n", m->m_pkthdr.len);
m_freem(n);
goto drop;
}
m_copydata(m, 0, m->m_pkthdr.len, n->m_data);
n->m_pkthdr.len = n->m_len = m->m_pkthdr.len;
n->m_pkthdr.csum_flags = (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA);
m_freem(m);
m = n;
}
vdata = (unsigned long)m->m_data;
old_mfn = vtomach(vdata) >> PAGE_SHIFT;
if ((new_mfn = alloc_mfn()) == 0)
goto drop;
#ifdef XEN_NETBACK_FIXUP_CSUM
/* Check if we need to compute a checksum. This happens */
/* when bridging from one domain to another. */
if ((m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) ||
(m->m_pkthdr.csum_flags & CSUM_SCTP))
fixup_checksum(m);
#endif
xen_phys_machine[(vtophys(vdata) >> PAGE_SHIFT)] = new_mfn;
mcl->op = __HYPERVISOR_update_va_mapping;
mcl->args[0] = vdata;
mcl->args[1] = (new_mfn << PAGE_SHIFT) | PG_V | PG_RW | PG_M | PG_A;
mcl->args[2] = 0;
mcl->args[3] = 0;
mcl++;
gop->mfn = old_mfn;
gop->domid = netif->domid;
gop->ref = RING_GET_REQUEST(&netif->rx, netif->rx.req_cons)->gref;
netif->rx.req_cons++;
gop++;
mmu->ptr = (new_mfn << PAGE_SHIFT) | MMU_MACHPHYS_UPDATE;
mmu->val = vtophys(vdata) >> PAGE_SHIFT;
mmu++;
if (rxq_last)
rxq_last->m_nextpkt = m;
else
rxq = m;
rxq_last = m;
DDPRINTF("XMIT %d bytes to %s\n", m->m_pkthdr.len, IFNAME(netif));
DPRINTF_MBUF_LEN(m, 128);
/* Filled the batch queue? */
if ((gop - grant_rx_op) == ARRAY_SIZE(grant_rx_op))
break;
continue;
drop:
DDPRINTF("dropping pkt\n");
ifp->if_oerrors++;
m_freem(m);
}
if (mcl == rx_mcl)
return pkts_dequeued;
mcl->op = __HYPERVISOR_mmu_update;
mcl->args[0] = (unsigned long)rx_mmu;
mcl->args[1] = mmu - rx_mmu;
mcl->args[2] = 0;
mcl->args[3] = DOMID_SELF;
mcl++;
mcl[-2].args[MULTI_UVMFLAGS_INDEX] = UVMF_TLB_FLUSH|UVMF_ALL;
ret = HYPERVISOR_multicall(rx_mcl, mcl - rx_mcl);
BUG_ON(ret != 0);
ret = HYPERVISOR_grant_table_op(GNTTABOP_transfer, grant_rx_op, gop - grant_rx_op);
BUG_ON(ret != 0);
mcl = rx_mcl;
gop = grant_rx_op;
while ((m = rxq) != NULL) {
int8_t status;
uint16_t id, flags = 0;
rxq = m->m_nextpkt;
m->m_nextpkt = NULL;
/* Rederive the machine addresses. */
new_mfn = mcl->args[1] >> PAGE_SHIFT;
old_mfn = gop->mfn;
ifp->if_obytes += m->m_pkthdr.len;
ifp->if_opackets++;
/* The update_va_mapping() must not fail. */
BUG_ON(mcl->result != 0);
/* Setup flags */
if ((m->m_pkthdr.csum_flags & CSUM_DELAY_DATA))
flags |= NETRXF_csum_blank | NETRXF_data_validated;
else if ((m->m_pkthdr.csum_flags & CSUM_DATA_VALID))
flags |= NETRXF_data_validated;
/* Check the reassignment error code. */
status = NETIF_RSP_OKAY;
if (gop->status != 0) {
DPRINTF("Bad status %d from grant transfer to DOM%u\n",
gop->status, netif->domid);
/*
* Page no longer belongs to us unless GNTST_bad_page,
* but that should be a fatal error anyway.
*/
BUG_ON(gop->status == GNTST_bad_page);
status = NETIF_RSP_ERROR;
}
id = RING_GET_REQUEST(&netif->rx, netif->rx.rsp_prod_pvt)->id;
notify |= make_rx_response(netif, id, status,
(unsigned long)m->m_data & PAGE_MASK,
m->m_pkthdr.len, flags);
m_freem(m);
mcl++;
gop++;
}
if (notify)
notify_remote_via_irq(netif->irq);
return pkts_dequeued;
}
static void
rx_task_timer(void *arg)
{
DDPRINTF("\n");
taskqueue_enqueue(taskqueue_swi, &net_rx_task);
}
static void
net_rx_action(void *context, int pending)
{
netif_t *netif, *last_zero_work = NULL;
DDPRINTF("\n");
while ((netif = remove_from_rx_schedule_list())) {
struct ifnet *ifp = netif->ifp;
if (netif == last_zero_work) {
if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
add_to_rx_schedule_list_tail(netif);
netif_put(netif);
if (!STAILQ_EMPTY(&rx_sched_list))
callout_reset(&rx_task_callout, 1, rx_task_timer, NULL);
break;
}
if ((ifp->if_drv_flags & IFF_DRV_RUNNING)) {
if (netif_rx(netif))
last_zero_work = NULL;
else if (!last_zero_work)
last_zero_work = netif;
if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
add_to_rx_schedule_list_tail(netif);
}
netif_put(netif);
}
}
static void
netback_start(struct ifnet *ifp)
{
netif_t *netif = (netif_t *)ifp->if_softc;
DDPRINTF("%s\n", IFNAME(netif));
add_to_rx_schedule_list_tail(netif);
taskqueue_enqueue(taskqueue_swi, &net_rx_task);
}
/* Map a grant ref to a ring */
static int
map_ring(grant_ref_t ref, domid_t dom, struct ring_ref *ring)
{
struct gnttab_map_grant_ref op;
ring->va = kmem_alloc_nofault(kernel_map, PAGE_SIZE);
if (ring->va == 0)
return ENOMEM;
op.host_addr = ring->va;
op.flags = GNTMAP_host_map;
op.ref = ref;
op.dom = dom;
HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
if (op.status) {
WPRINTF("grant table op err=%d\n", op.status);
kmem_free(kernel_map, ring->va, PAGE_SIZE);
ring->va = 0;
return EACCES;
}
ring->handle = op.handle;
ring->bus_addr = op.dev_bus_addr;
return 0;
}
/* Unmap grant ref for a ring */
static void
unmap_ring(struct ring_ref *ring)
{
struct gnttab_unmap_grant_ref op;
op.host_addr = ring->va;
op.dev_bus_addr = ring->bus_addr;
op.handle = ring->handle;
HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
if (op.status)
WPRINTF("grant table op err=%d\n", op.status);
kmem_free(kernel_map, ring->va, PAGE_SIZE);
ring->va = 0;
}
static int
connect_rings(netif_t *netif)
{
struct xenbus_device *xdev = netif->xdev;
netif_tx_sring_t *txs;
netif_rx_sring_t *rxs;
unsigned long tx_ring_ref, rx_ring_ref;
evtchn_port_t evtchn;
evtchn_op_t op = { .cmd = EVTCHNOP_bind_interdomain };
int err;
// Grab FE data and map his memory
err = xenbus_gather(NULL, xdev->otherend,
"tx-ring-ref", "%lu", &tx_ring_ref,
"rx-ring-ref", "%lu", &rx_ring_ref,
"event-channel", "%u", &evtchn, NULL);
if (err) {
xenbus_dev_fatal(xdev, err,
"reading %s/ring-ref and event-channel",
xdev->otherend);
return err;
}
err = map_ring(tx_ring_ref, netif->domid, &netif->tx_ring_ref);
if (err) {
xenbus_dev_fatal(xdev, err, "mapping tx ring");
return err;
}
txs = (netif_tx_sring_t *)netif->tx_ring_ref.va;
BACK_RING_INIT(&netif->tx, txs, PAGE_SIZE);
err = map_ring(rx_ring_ref, netif->domid, &netif->rx_ring_ref);
if (err) {
unmap_ring(&netif->tx_ring_ref);
xenbus_dev_fatal(xdev, err, "mapping rx ring");
return err;
}
rxs = (netif_rx_sring_t *)netif->rx_ring_ref.va;
BACK_RING_INIT(&netif->rx, rxs, PAGE_SIZE);
op.u.bind_interdomain.remote_dom = netif->domid;
op.u.bind_interdomain.remote_port = evtchn;
err = HYPERVISOR_event_channel_op(&op);
if (err) {
unmap_ring(&netif->tx_ring_ref);
unmap_ring(&netif->rx_ring_ref);
xenbus_dev_fatal(xdev, err, "binding event channel");
return err;
}
netif->evtchn = op.u.bind_interdomain.local_port;
/* bind evtchn to irq handler */
netif->irq =
bind_evtchn_to_irqhandler(netif->evtchn, "netback",
netback_intr, netif, INTR_TYPE_NET|INTR_MPSAFE, &netif->irq_cookie);
netif->rings_connected = 1;
DPRINTF("%s connected! evtchn=%d irq=%d\n",
IFNAME(netif), netif->evtchn, netif->irq);
return 0;
}
static void
disconnect_rings(netif_t *netif)
{
DPRINTF("\n");
if (netif->rings_connected) {
unbind_from_irqhandler(netif->irq, netif->irq_cookie);
netif->irq = 0;
unmap_ring(&netif->tx_ring_ref);
unmap_ring(&netif->rx_ring_ref);
netif->rings_connected = 0;
}
}
static void
connect(netif_t *netif)
{
if (!netif->xdev ||
!netif->attached ||
netif->frontend_state != XenbusStateConnected) {
return;
}
if (!connect_rings(netif)) {
xenbus_switch_state(netif->xdev, NULL, XenbusStateConnected);
/* Turn on interface */
netif->ifp->if_drv_flags |= IFF_DRV_RUNNING;
netif->ifp->if_flags |= IFF_UP;
}
}
static int
netback_remove(struct xenbus_device *xdev)
{
netif_t *netif = xdev->data;
device_t ndev;
DPRINTF("remove %s\n", xdev->nodename);
if ((ndev = netif->ndev)) {
netif->ndev = NULL;
mtx_lock(&Giant);
device_detach(ndev);
mtx_unlock(&Giant);
}
xdev->data = NULL;
netif->xdev = NULL;
netif_put(netif);
return 0;
}
/**
* Entry point to this code when a new device is created. Allocate the basic
* structures and the ring buffers for communication with the frontend.
* Switch to Connected state.
*/
static int
netback_probe(struct xenbus_device *xdev, const struct xenbus_device_id *id)
{
int err;
long handle;
char *bridge;
DPRINTF("node=%s\n", xdev->nodename);
/* Grab the handle */
err = xenbus_scanf(NULL, xdev->nodename, "handle", "%li", &handle);
if (err != 1) {
xenbus_dev_fatal(xdev, err, "reading handle");
return err;
}
/* Check for bridge */
bridge = xenbus_read(NULL, xdev->nodename, "bridge", NULL);
if (IS_ERR(bridge))
bridge = NULL;
err = xenbus_switch_state(xdev, NULL, XenbusStateInitWait);
if (err) {
xenbus_dev_fatal(xdev, err, "writing switch state");
return err;
}
err = netif_create(handle, xdev, bridge);
if (err) {
xenbus_dev_fatal(xdev, err, "creating netif");
return err;
}
err = vif_add_dev(xdev);
if (err) {
netif_put((netif_t *)xdev->data);
xenbus_dev_fatal(xdev, err, "adding vif device");
return err;
}
return 0;
}
/**
* We are reconnecting to the backend, due to a suspend/resume, or a backend
* driver restart. We tear down our netif structure and recreate it, but
* leave the device-layer structures intact so that this is transparent to the
* rest of the kernel.
*/
static int netback_resume(struct xenbus_device *xdev)
{
DPRINTF("node=%s\n", xdev->nodename);
return 0;
}
/**
* Callback received when the frontend's state changes.
*/
static void frontend_changed(struct xenbus_device *xdev,
XenbusState frontend_state)
{
netif_t *netif = xdev->data;
DPRINTF("state=%d\n", frontend_state);
netif->frontend_state = frontend_state;
switch (frontend_state) {
case XenbusStateInitialising:
case XenbusStateInitialised:
break;
case XenbusStateConnected:
connect(netif);
break;
case XenbusStateClosing:
xenbus_switch_state(xdev, NULL, XenbusStateClosing);
break;
case XenbusStateClosed:
xenbus_remove_device(xdev);
break;
case XenbusStateUnknown:
case XenbusStateInitWait:
xenbus_dev_fatal(xdev, EINVAL, "saw state %d at frontend",
frontend_state);
break;
}
}
/* ** Driver registration ** */
static struct xenbus_device_id netback_ids[] = {
{ "vif" },
{ "" }
};
static struct xenbus_driver netback = {
.name = "netback",
.ids = netback_ids,
.probe = netback_probe,
.remove = netback_remove,
.resume= netback_resume,
.otherend_changed = frontend_changed,
};
static void
netback_init(void *unused)
{
callout_init(&rx_task_callout, CALLOUT_MPSAFE);
mmap_vstart = alloc_empty_page_range(MAX_PENDING_REQS);
BUG_ON(!mmap_vstart);
pending_cons = 0;
for (pending_prod = 0; pending_prod < MAX_PENDING_REQS; pending_prod++)
pending_ring[pending_prod] = pending_prod;
TASK_INIT(&net_tx_task, 0, net_tx_action, NULL);
TASK_INIT(&net_rx_task, 0, net_rx_action, NULL);
mtx_init(&tx_sched_list_lock, "nb_tx_sched_lock", "netback tx sched lock", MTX_DEF);
mtx_init(&rx_sched_list_lock, "nb_rx_sched_lock", "netback rx sched lock", MTX_DEF);
DPRINTF("registering %s\n", netback.name);
xenbus_register_backend(&netback);
}
SYSINIT(xnbedev, SI_SUB_PSEUDO, SI_ORDER_ANY, netback_init, NULL)
static int
vif_add_dev(struct xenbus_device *xdev)
{
netif_t *netif = xdev->data;
device_t nexus, ndev;
devclass_t dc;
int err = 0;
mtx_lock(&Giant);
/* We will add a vif device as a child of nexus0 (for now) */
if (!(dc = devclass_find("nexus")) ||
!(nexus = devclass_get_device(dc, 0))) {
WPRINTF("could not find nexus0!\n");
err = ENOENT;
goto done;
}
/* Create a newbus device representing the vif */
ndev = BUS_ADD_CHILD(nexus, 0, "vif", netif->ifp->if_dunit);
if (!ndev) {
WPRINTF("could not create newbus device %s!\n", IFNAME(netif));
err = EFAULT;
goto done;
}
netif_get(netif);
device_set_ivars(ndev, netif);
netif->ndev = ndev;
device_probe_and_attach(ndev);
done:
mtx_unlock(&Giant);
return err;
}
enum {
VIF_SYSCTL_DOMID,
VIF_SYSCTL_HANDLE,
VIF_SYSCTL_TXRING,
VIF_SYSCTL_RXRING,
};
static char *
vif_sysctl_ring_info(netif_t *netif, int cmd)
{
char *buf = malloc(256, M_DEVBUF, M_WAITOK);
if (buf) {
if (!netif->rings_connected)
sprintf(buf, "rings not connected\n");
else if (cmd == VIF_SYSCTL_TXRING) {
netif_tx_back_ring_t *tx = &netif->tx;
sprintf(buf, "nr_ents=%x req_cons=%x"
" req_prod=%x req_event=%x"
" rsp_prod=%x rsp_event=%x",
tx->nr_ents, tx->req_cons,
tx->sring->req_prod, tx->sring->req_event,
tx->sring->rsp_prod, tx->sring->rsp_event);
} else {
netif_rx_back_ring_t *rx = &netif->rx;
sprintf(buf, "nr_ents=%x req_cons=%x"
" req_prod=%x req_event=%x"
" rsp_prod=%x rsp_event=%x",
rx->nr_ents, rx->req_cons,
rx->sring->req_prod, rx->sring->req_event,
rx->sring->rsp_prod, rx->sring->rsp_event);
}
}
return buf;
}
static int
vif_sysctl_handler(SYSCTL_HANDLER_ARGS)
{
device_t dev = (device_t)arg1;
netif_t *netif = (netif_t *)device_get_ivars(dev);
const char *value;
char *buf = NULL;
int err;
switch (arg2) {
case VIF_SYSCTL_DOMID:
return sysctl_handle_int(oidp, NULL, netif->domid, req);
case VIF_SYSCTL_HANDLE:
return sysctl_handle_int(oidp, NULL, netif->handle, req);
case VIF_SYSCTL_TXRING:
case VIF_SYSCTL_RXRING:
value = buf = vif_sysctl_ring_info(netif, arg2);
break;
default:
return (EINVAL);
}
err = SYSCTL_OUT(req, value, strlen(value));
if (buf != NULL)
free(buf, M_DEVBUF);
return err;
}
/* Newbus vif device driver probe */
static int
vif_probe(device_t dev)
{
DDPRINTF("vif%d\n", device_get_unit(dev));
return 0;
}
/* Newbus vif device driver attach */
static int
vif_attach(device_t dev)
{
netif_t *netif = (netif_t *)device_get_ivars(dev);
uint8_t mac[ETHER_ADDR_LEN];
DDPRINTF("%s\n", IFNAME(netif));
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "domid", CTLTYPE_INT|CTLFLAG_RD,
dev, VIF_SYSCTL_DOMID, vif_sysctl_handler, "I",
"domid of frontend");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "handle", CTLTYPE_INT|CTLFLAG_RD,
dev, VIF_SYSCTL_HANDLE, vif_sysctl_handler, "I",
"handle of frontend");
#ifdef XEN_NETBACK_DEBUG
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "txring", CTLFLAG_RD,
dev, VIF_SYSCTL_TXRING, vif_sysctl_handler, "A",
"tx ring info");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "rxring", CTLFLAG_RD,
dev, VIF_SYSCTL_RXRING, vif_sysctl_handler, "A",
"rx ring info");
#endif
memset(mac, 0xff, sizeof(mac));
mac[0] &= ~0x01;
ether_ifattach(netif->ifp, mac);
netif->attached = 1;
connect(netif);
if (netif->bridge) {
DPRINTF("Adding %s to bridge %s\n", IFNAME(netif), netif->bridge);
int err = add_to_bridge(netif->ifp, netif->bridge);
if (err) {
WPRINTF("Error adding %s to %s; err=%d\n",
IFNAME(netif), netif->bridge, err);
}
}
return bus_generic_attach(dev);
}
/* Newbus vif device driver detach */
static int
vif_detach(device_t dev)
{
netif_t *netif = (netif_t *)device_get_ivars(dev);
struct ifnet *ifp = netif->ifp;
DDPRINTF("%s\n", IFNAME(netif));
/* Tell the stack that the interface is no longer active */
ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
ether_ifdetach(ifp);
bus_generic_detach(dev);
netif->attached = 0;
netif_put(netif);
return 0;
}
static device_method_t vif_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, vif_probe),
DEVMETHOD(device_attach, vif_attach),
DEVMETHOD(device_detach, vif_detach),
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(device_suspend, bus_generic_suspend),
DEVMETHOD(device_resume, bus_generic_resume),
{0, 0}
};
static devclass_t vif_devclass;
static driver_t vif_driver = {
"vif",
vif_methods,
0,
};
DRIVER_MODULE(vif, nexus, vif_driver, vif_devclass, 0, 0);
/*
* Local variables:
* mode: C
* c-set-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: t
* End:
*/
Reference in New Issue View Git Blame Copy Permalink