remove stale and unused code from various files
fix build on 32 bit platforms simplify logic in netmap_virt.h The commands (in net/netmap.h) to configure communication with the hypervisor may be revised soon. At the moment they are unused so this will not be a change of API.
This commit is contained in:
parent
d782d9fd35
commit
a2a7409151
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=307574
@ -35,12 +35,8 @@
|
||||
|
||||
#include <net/netmap.h>
|
||||
#include <sys/selinfo.h>
|
||||
#include <vm/vm.h>
|
||||
#include <vm/pmap.h> /* vtophys ? */
|
||||
#include <dev/netmap/netmap_kern.h>
|
||||
|
||||
extern int netmap_adaptive_io;
|
||||
|
||||
/*
|
||||
* Register/unregister. We are already under netmap lock.
|
||||
*/
|
||||
|
@ -341,7 +341,11 @@ ptnet_attach(device_t dev)
|
||||
}
|
||||
|
||||
{
|
||||
vm_paddr_t paddr = vtophys(sc->csb);
|
||||
/*
|
||||
* We use uint64_t rather than vm_paddr_t since we
|
||||
* need 64 bit addresses even on 32 bit platforms.
|
||||
*/
|
||||
uint64_t paddr = vtophys(sc->csb);
|
||||
|
||||
bus_write_4(sc->iomem, PTNET_IO_CSBBAH,
|
||||
(paddr >> 32) & 0xffffffff);
|
||||
@ -1139,9 +1143,11 @@ ptnet_sync_from_csb(struct ptnet_softc *sc, struct netmap_adapter *na)
|
||||
static void
|
||||
ptnet_update_vnet_hdr(struct ptnet_softc *sc)
|
||||
{
|
||||
sc->vnet_hdr_len = ptnet_vnet_hdr ? PTNET_HDR_SIZE : 0;
|
||||
unsigned int wanted_hdr_len = ptnet_vnet_hdr ? PTNET_HDR_SIZE : 0;
|
||||
|
||||
bus_write_4(sc->iomem, PTNET_IO_VNET_HDR_LEN, wanted_hdr_len);
|
||||
sc->vnet_hdr_len = bus_read_4(sc->iomem, PTNET_IO_VNET_HDR_LEN);
|
||||
sc->ptna->hwup.up.virt_hdr_len = sc->vnet_hdr_len;
|
||||
bus_write_4(sc->iomem, PTNET_IO_VNET_HDR_LEN, sc->vnet_hdr_len);
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -483,7 +483,6 @@ static int netmap_no_timestamp; /* don't timestamp on rxsync */
|
||||
int netmap_mitigate = 1;
|
||||
int netmap_no_pendintr = 1;
|
||||
int netmap_txsync_retry = 2;
|
||||
int netmap_adaptive_io = 0;
|
||||
int netmap_flags = 0; /* debug flags */
|
||||
static int netmap_fwd = 0; /* force transparent mode */
|
||||
|
||||
@ -540,8 +539,6 @@ SYSCTL_INT(_dev_netmap, OID_AUTO, no_pendintr,
|
||||
CTLFLAG_RW, &netmap_no_pendintr, 0, "Always look for new received packets.");
|
||||
SYSCTL_INT(_dev_netmap, OID_AUTO, txsync_retry, CTLFLAG_RW,
|
||||
&netmap_txsync_retry, 0 , "Number of txsync loops in bridge's flush.");
|
||||
SYSCTL_INT(_dev_netmap, OID_AUTO, adaptive_io, CTLFLAG_RW,
|
||||
&netmap_adaptive_io, 0 , "Adaptive I/O on paravirt");
|
||||
|
||||
SYSCTL_INT(_dev_netmap, OID_AUTO, flags, CTLFLAG_RW, &netmap_flags, 0 , "");
|
||||
SYSCTL_INT(_dev_netmap, OID_AUTO, fwd, CTLFLAG_RW, &netmap_fwd, 0 , "");
|
||||
@ -1559,7 +1556,7 @@ nm_txsync_prologue(struct netmap_kring *kring, struct netmap_ring *ring)
|
||||
}
|
||||
}
|
||||
if (ring->tail != kring->rtail) {
|
||||
RD(5, "tail overwritten was %d need %d",
|
||||
RD(5, "%s tail overwritten was %d need %d", kring->name,
|
||||
ring->tail, kring->rtail);
|
||||
ring->tail = kring->rtail;
|
||||
}
|
||||
|
@ -353,7 +353,7 @@ nm_os_generic_xmit_frame(struct nm_os_gen_arg *a)
|
||||
bcopy(a->addr, m->m_data, len);
|
||||
#else /* __FreeBSD_version >= 1100000 */
|
||||
/* New FreeBSD versions. Link the external storage to
|
||||
* the netmap buffer, so that no copy is necessary. */
|
||||
* the netmap buffer, so that no copy is necessary. */
|
||||
m->m_ext.ext_buf = m->m_data = a->addr;
|
||||
m->m_ext.ext_size = len;
|
||||
#endif /* __FreeBSD_version >= 1100000 */
|
||||
@ -644,7 +644,8 @@ DRIVER_MODULE_ORDERED(ptn_memdev, pci, ptn_memdev_driver, ptnetmap_devclass,
|
||||
* of the netmap memory mapped in the guest.
|
||||
*/
|
||||
int
|
||||
nm_os_pt_memdev_iomap(struct ptnetmap_memdev *ptn_dev, vm_paddr_t *nm_paddr, void **nm_addr)
|
||||
nm_os_pt_memdev_iomap(struct ptnetmap_memdev *ptn_dev, vm_paddr_t *nm_paddr,
|
||||
void **nm_addr)
|
||||
{
|
||||
uint32_t mem_size;
|
||||
int rid;
|
||||
@ -668,8 +669,8 @@ nm_os_pt_memdev_iomap(struct ptnetmap_memdev *ptn_dev, vm_paddr_t *nm_paddr, voi
|
||||
|
||||
D("=== BAR %d start %lx len %lx mem_size %x ===",
|
||||
PTNETMAP_MEM_PCI_BAR,
|
||||
*nm_paddr,
|
||||
rman_get_size(ptn_dev->pci_mem),
|
||||
(unsigned long)(*nm_paddr),
|
||||
(unsigned long)rman_get_size(ptn_dev->pci_mem),
|
||||
mem_size);
|
||||
return (0);
|
||||
}
|
||||
|
@ -95,7 +95,7 @@ __FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* For older versions of FreeBSD:
|
||||
*
|
||||
*
|
||||
* We allocate EXT_PACKET mbuf+clusters, but need to set M_NOFREE
|
||||
* so that the destructor, if invoked, will not free the packet.
|
||||
* In principle we should set the destructor only on demand,
|
||||
@ -628,8 +628,6 @@ generic_mbuf_destructor(struct mbuf *m)
|
||||
#endif
|
||||
}
|
||||
|
||||
extern int netmap_adaptive_io;
|
||||
|
||||
/* Record completed transmissions and update hwtail.
|
||||
*
|
||||
* The oldest tx buffer not yet completed is at nr_hwtail + 1,
|
||||
@ -690,23 +688,6 @@ generic_netmap_tx_clean(struct netmap_kring *kring, int txqdisc)
|
||||
|
||||
n++;
|
||||
nm_i = nm_next(nm_i, lim);
|
||||
#if 0 /* rate adaptation */
|
||||
if (netmap_adaptive_io > 1) {
|
||||
if (n >= netmap_adaptive_io)
|
||||
break;
|
||||
} else if (netmap_adaptive_io) {
|
||||
/* if hwcur - nm_i < lim/8 do an early break
|
||||
* so we prevent the sender from stalling. See CVT.
|
||||
*/
|
||||
if (hwcur >= nm_i) {
|
||||
if (hwcur - nm_i < lim/2)
|
||||
break;
|
||||
} else {
|
||||
if (hwcur + lim + 1 - nm_i < lim/2)
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
kring->nr_hwtail = nm_prev(nm_i, lim);
|
||||
ND("tx completed [%d] -> hwtail %d", n, kring->nr_hwtail);
|
||||
|
@ -1512,9 +1512,9 @@ int netmap_adapter_put(struct netmap_adapter *na);
|
||||
*/
|
||||
#define NETMAP_BUF_BASE(_na) ((_na)->na_lut.lut[0].vaddr)
|
||||
#define NETMAP_BUF_SIZE(_na) ((_na)->na_lut.objsize)
|
||||
extern int netmap_mitigate; // XXX not really used
|
||||
extern int netmap_no_pendintr;
|
||||
extern int netmap_verbose; // XXX debugging
|
||||
extern int netmap_mitigate;
|
||||
extern int netmap_verbose; /* for debugging */
|
||||
enum { /* verbose flags */
|
||||
NM_VERB_ON = 1, /* generic verbose */
|
||||
NM_VERB_HOST = 0x2, /* verbose host stack */
|
||||
@ -1527,7 +1527,6 @@ enum { /* verbose flags */
|
||||
};
|
||||
|
||||
extern int netmap_txsync_retry;
|
||||
extern int netmap_adaptive_io;
|
||||
extern int netmap_flags;
|
||||
extern int netmap_generic_mit;
|
||||
extern int netmap_generic_ringsize;
|
||||
|
@ -64,13 +64,10 @@
|
||||
* results in random drops in the VALE txsync. */
|
||||
//#define PTN_TX_BATCH_LIM(_n) ((_n >> 1))
|
||||
|
||||
/* XXX: avoid nm_*sync_prologue(). XXX-vin: this should go away,
|
||||
* we should never trust the guest. */
|
||||
#define PTN_AVOID_NM_PROLOGUE
|
||||
//#define BUSY_WAIT
|
||||
|
||||
#define DEBUG /* Enables communication debugging. */
|
||||
#ifdef DEBUG
|
||||
#define NETMAP_PT_DEBUG /* Enables communication debugging. */
|
||||
#ifdef NETMAP_PT_DEBUG
|
||||
#define DBG(x) x
|
||||
#else
|
||||
#define DBG(x)
|
||||
@ -196,22 +193,6 @@ ptnetmap_kring_dump(const char *title, const struct netmap_kring *kring)
|
||||
kring->ring->head, kring->ring->cur, kring->ring->tail);
|
||||
}
|
||||
|
||||
#if 0
|
||||
static inline void
|
||||
ptnetmap_ring_reinit(struct netmap_kring *kring, uint32_t g_head, uint32_t g_cur)
|
||||
{
|
||||
struct netmap_ring *ring = kring->ring;
|
||||
|
||||
//XXX: trust guest?
|
||||
ring->head = g_head;
|
||||
ring->cur = g_cur;
|
||||
ring->tail = NM_ACCESS_ONCE(kring->nr_hwtail);
|
||||
|
||||
netmap_ring_reinit(kring);
|
||||
ptnetmap_kring_dump("kring reinit", kring);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* TX functions to set/get and to handle host/guest kick.
|
||||
*/
|
||||
@ -251,7 +232,7 @@ ptnetmap_tx_handler(void *data)
|
||||
(struct netmap_pt_host_adapter *)kring->na->na_private;
|
||||
struct ptnetmap_state *ptns = pth_na->ptns;
|
||||
struct ptnet_ring __user *ptring;
|
||||
struct netmap_ring g_ring; /* guest ring pointer, copied from CSB */
|
||||
struct netmap_ring shadow_ring; /* shadow copy of the netmap_ring */
|
||||
bool more_txspace = false;
|
||||
struct nm_kthread *kth;
|
||||
uint32_t num_slots;
|
||||
@ -281,18 +262,18 @@ ptnetmap_tx_handler(void *data)
|
||||
kth = ptns->kthreads[kring->ring_id];
|
||||
|
||||
num_slots = kring->nkr_num_slots;
|
||||
g_ring.head = kring->rhead;
|
||||
g_ring.cur = kring->rcur;
|
||||
shadow_ring.head = kring->rhead;
|
||||
shadow_ring.cur = kring->rcur;
|
||||
|
||||
/* Disable guest --> host notifications. */
|
||||
ptring_kick_enable(ptring, 0);
|
||||
/* Copy the guest kring pointers from the CSB */
|
||||
ptnetmap_host_read_kring_csb(ptring, &g_ring, num_slots);
|
||||
ptnetmap_host_read_kring_csb(ptring, &shadow_ring, num_slots);
|
||||
|
||||
for (;;) {
|
||||
/* If guest moves ahead too fast, let's cut the move so
|
||||
* that we don't exceed our batch limit. */
|
||||
batch = g_ring.head - kring->nr_hwcur;
|
||||
batch = shadow_ring.head - kring->nr_hwcur;
|
||||
if (batch < 0)
|
||||
batch += num_slots;
|
||||
|
||||
@ -302,37 +283,35 @@ ptnetmap_tx_handler(void *data)
|
||||
|
||||
if (head_lim >= num_slots)
|
||||
head_lim -= num_slots;
|
||||
ND(1, "batch: %d head: %d head_lim: %d", batch, g_ring.head,
|
||||
ND(1, "batch: %d head: %d head_lim: %d", batch, shadow_ring.head,
|
||||
head_lim);
|
||||
g_ring.head = head_lim;
|
||||
shadow_ring.head = head_lim;
|
||||
batch = PTN_TX_BATCH_LIM(num_slots);
|
||||
}
|
||||
#endif /* PTN_TX_BATCH_LIM */
|
||||
|
||||
if (nm_kr_txspace(kring) <= (num_slots >> 1)) {
|
||||
g_ring.flags |= NAF_FORCE_RECLAIM;
|
||||
shadow_ring.flags |= NAF_FORCE_RECLAIM;
|
||||
}
|
||||
#ifndef PTN_AVOID_NM_PROLOGUE
|
||||
|
||||
/* Netmap prologue */
|
||||
if (unlikely(nm_txsync_prologue(kring, &g_ring) >= num_slots)) {
|
||||
ptnetmap_ring_reinit(kring, g_ring.head, g_ring.cur);
|
||||
/* Reenable notifications. */
|
||||
shadow_ring.tail = kring->rtail;
|
||||
if (unlikely(nm_txsync_prologue(kring, &shadow_ring) >= num_slots)) {
|
||||
/* Reinit ring and enable notifications. */
|
||||
netmap_ring_reinit(kring);
|
||||
ptring_kick_enable(ptring, 1);
|
||||
break;
|
||||
}
|
||||
#else /* PTN_AVOID_NM_PROLOGUE */
|
||||
kring->rhead = g_ring.head;
|
||||
kring->rcur = g_ring.cur;
|
||||
#endif /* !PTN_AVOID_NM_PROLOGUE */
|
||||
|
||||
if (unlikely(netmap_verbose & NM_VERB_TXSYNC)) {
|
||||
ptnetmap_kring_dump("pre txsync", kring);
|
||||
}
|
||||
|
||||
IFRATE(pre_tail = kring->rtail);
|
||||
if (unlikely(kring->nm_sync(kring, g_ring.flags))) {
|
||||
if (unlikely(kring->nm_sync(kring, shadow_ring.flags))) {
|
||||
/* Reenable notifications. */
|
||||
ptring_kick_enable(ptring, 1);
|
||||
D("ERROR txsync");
|
||||
D("ERROR txsync()");
|
||||
break;
|
||||
}
|
||||
|
||||
@ -350,7 +329,7 @@ ptnetmap_tx_handler(void *data)
|
||||
}
|
||||
|
||||
IFRATE(rate_batch_stats_update(&ptns->rate_ctx.new.txbs, pre_tail,
|
||||
kring->rtail, num_slots));
|
||||
kring->rtail, num_slots));
|
||||
|
||||
if (unlikely(netmap_verbose & NM_VERB_TXSYNC)) {
|
||||
ptnetmap_kring_dump("post txsync", kring);
|
||||
@ -367,9 +346,9 @@ ptnetmap_tx_handler(void *data)
|
||||
}
|
||||
#endif
|
||||
/* Read CSB to see if there is more work to do. */
|
||||
ptnetmap_host_read_kring_csb(ptring, &g_ring, num_slots);
|
||||
ptnetmap_host_read_kring_csb(ptring, &shadow_ring, num_slots);
|
||||
#ifndef BUSY_WAIT
|
||||
if (g_ring.head == kring->rhead) {
|
||||
if (shadow_ring.head == kring->rhead) {
|
||||
/*
|
||||
* No more packets to transmit. We enable notifications and
|
||||
* go to sleep, waiting for a kick from the guest when new
|
||||
@ -379,8 +358,8 @@ ptnetmap_tx_handler(void *data)
|
||||
/* Reenable notifications. */
|
||||
ptring_kick_enable(ptring, 1);
|
||||
/* Doublecheck. */
|
||||
ptnetmap_host_read_kring_csb(ptring, &g_ring, num_slots);
|
||||
if (g_ring.head != kring->rhead) {
|
||||
ptnetmap_host_read_kring_csb(ptring, &shadow_ring, num_slots);
|
||||
if (shadow_ring.head != kring->rhead) {
|
||||
/* We won the race condition, there are more packets to
|
||||
* transmit. Disable notifications and do another cycle */
|
||||
ptring_kick_enable(ptring, 0);
|
||||
@ -433,7 +412,7 @@ ptnetmap_rx_handler(void *data)
|
||||
(struct netmap_pt_host_adapter *)kring->na->na_private;
|
||||
struct ptnetmap_state *ptns = pth_na->ptns;
|
||||
struct ptnet_ring __user *ptring;
|
||||
struct netmap_ring g_ring; /* guest ring pointer, copied from CSB */
|
||||
struct netmap_ring shadow_ring; /* shadow copy of the netmap_ring */
|
||||
struct nm_kthread *kth;
|
||||
uint32_t num_slots;
|
||||
int dry_cycles = 0;
|
||||
@ -464,36 +443,32 @@ ptnetmap_rx_handler(void *data)
|
||||
kth = ptns->kthreads[pth_na->up.num_tx_rings + kring->ring_id];
|
||||
|
||||
num_slots = kring->nkr_num_slots;
|
||||
g_ring.head = kring->rhead;
|
||||
g_ring.cur = kring->rcur;
|
||||
shadow_ring.head = kring->rhead;
|
||||
shadow_ring.cur = kring->rcur;
|
||||
|
||||
/* Disable notifications. */
|
||||
ptring_kick_enable(ptring, 0);
|
||||
/* Copy the guest kring pointers from the CSB */
|
||||
ptnetmap_host_read_kring_csb(ptring, &g_ring, num_slots);
|
||||
ptnetmap_host_read_kring_csb(ptring, &shadow_ring, num_slots);
|
||||
|
||||
for (;;) {
|
||||
uint32_t hwtail;
|
||||
|
||||
#ifndef PTN_AVOID_NM_PROLOGUE
|
||||
/* Netmap prologue */
|
||||
if (unlikely(nm_rxsync_prologue(kring, &g_ring) >= num_slots)) {
|
||||
ptnetmap_ring_reinit(kring, g_ring.head, g_ring.cur);
|
||||
/* Reenable notifications. */
|
||||
shadow_ring.tail = kring->rtail;
|
||||
if (unlikely(nm_rxsync_prologue(kring, &shadow_ring) >= num_slots)) {
|
||||
/* Reinit ring and enable notifications. */
|
||||
netmap_ring_reinit(kring);
|
||||
ptring_kick_enable(ptring, 1);
|
||||
break;
|
||||
}
|
||||
#else /* PTN_AVOID_NM_PROLOGUE */
|
||||
kring->rhead = g_ring.head;
|
||||
kring->rcur = g_ring.cur;
|
||||
#endif /* !PTN_AVOID_NM_PROLOGUE */
|
||||
|
||||
if (unlikely(netmap_verbose & NM_VERB_RXSYNC))
|
||||
if (unlikely(netmap_verbose & NM_VERB_RXSYNC)) {
|
||||
ptnetmap_kring_dump("pre rxsync", kring);
|
||||
}
|
||||
|
||||
IFRATE(pre_tail = kring->rtail);
|
||||
|
||||
if (unlikely(kring->nm_sync(kring, g_ring.flags))) {
|
||||
if (unlikely(kring->nm_sync(kring, shadow_ring.flags))) {
|
||||
/* Reenable notifications. */
|
||||
ptring_kick_enable(ptring, 1);
|
||||
D("ERROR rxsync()");
|
||||
@ -516,8 +491,9 @@ ptnetmap_rx_handler(void *data)
|
||||
IFRATE(rate_batch_stats_update(&ptns->rate_ctx.new.rxbs, pre_tail,
|
||||
kring->rtail, num_slots));
|
||||
|
||||
if (unlikely(netmap_verbose & NM_VERB_RXSYNC))
|
||||
if (unlikely(netmap_verbose & NM_VERB_RXSYNC)) {
|
||||
ptnetmap_kring_dump("post rxsync", kring);
|
||||
}
|
||||
|
||||
#ifndef BUSY_WAIT
|
||||
/* Interrupt the guest if needed. */
|
||||
@ -530,9 +506,9 @@ ptnetmap_rx_handler(void *data)
|
||||
}
|
||||
#endif
|
||||
/* Read CSB to see if there is more work to do. */
|
||||
ptnetmap_host_read_kring_csb(ptring, &g_ring, num_slots);
|
||||
ptnetmap_host_read_kring_csb(ptring, &shadow_ring, num_slots);
|
||||
#ifndef BUSY_WAIT
|
||||
if (ptnetmap_norxslots(kring, g_ring.head)) {
|
||||
if (ptnetmap_norxslots(kring, shadow_ring.head)) {
|
||||
/*
|
||||
* No more slots available for reception. We enable notification and
|
||||
* go to sleep, waiting for a kick from the guest when new receive
|
||||
@ -542,8 +518,8 @@ ptnetmap_rx_handler(void *data)
|
||||
/* Reenable notifications. */
|
||||
ptring_kick_enable(ptring, 1);
|
||||
/* Doublecheck. */
|
||||
ptnetmap_host_read_kring_csb(ptring, &g_ring, num_slots);
|
||||
if (!ptnetmap_norxslots(kring, g_ring.head)) {
|
||||
ptnetmap_host_read_kring_csb(ptring, &shadow_ring, num_slots);
|
||||
if (!ptnetmap_norxslots(kring, shadow_ring.head)) {
|
||||
/* We won the race condition, more slots are available. Disable
|
||||
* notifications and do another cycle. */
|
||||
ptring_kick_enable(ptring, 0);
|
||||
@ -578,7 +554,7 @@ ptnetmap_rx_handler(void *data)
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
#ifdef NETMAP_PT_DEBUG
|
||||
static void
|
||||
ptnetmap_print_configuration(struct ptnetmap_cfg *cfg)
|
||||
{
|
||||
@ -594,7 +570,7 @@ ptnetmap_print_configuration(struct ptnetmap_cfg *cfg)
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
#endif /* NETMAP_PT_DEBUG */
|
||||
|
||||
/* Copy actual state of the host ring into the CSB for the guest init */
|
||||
static int
|
||||
|
@ -655,8 +655,8 @@ struct ptn_vmm_ioctl_msix {
|
||||
|
||||
/* IOCTL parameters */
|
||||
struct nm_kth_ioctl {
|
||||
u_long com;
|
||||
/* TODO: use union */
|
||||
uint64_t com;
|
||||
/* We use union to support more ioctl commands. */
|
||||
union {
|
||||
struct ptn_vmm_ioctl_msix msix;
|
||||
} data;
|
||||
@ -667,5 +667,6 @@ struct ptnet_ring_cfg {
|
||||
uint64_t ioeventfd; /* eventfd in linux, tsleep() parameter in FreeBSD */
|
||||
uint64_t irqfd; /* eventfd in linux, ioctl fd in FreeBSD */
|
||||
struct nm_kth_ioctl ioctl; /* ioctl parameter to send irq (only used in bhyve/FreeBSD) */
|
||||
uint64_t reserved[4]; /* reserved to support of more hypervisors */
|
||||
};
|
||||
#endif /* _NET_NETMAP_H_ */
|
||||
|
@ -58,13 +58,11 @@
|
||||
|
||||
/* Registers for the ptnetmap memdev */
|
||||
/* 32 bit r/o */
|
||||
#define PTNETMAP_IO_PCI_FEATURES 0 /* XXX should be removed */
|
||||
/* 32 bit r/o */
|
||||
#define PTNETMAP_IO_PCI_MEMSIZE 4 /* size of the netmap memory shared
|
||||
#define PTNETMAP_IO_PCI_MEMSIZE 0 /* size of the netmap memory shared
|
||||
* between guest and host */
|
||||
/* 16 bit r/o */
|
||||
#define PTNETMAP_IO_PCI_HOSTID 8 /* memory allocator ID in netmap host */
|
||||
#define PTNETMAP_IO_SIZE 10
|
||||
#define PTNETMAP_IO_PCI_HOSTID 4 /* memory allocator ID in netmap host */
|
||||
#define PTNETMAP_IO_SIZE 6
|
||||
|
||||
/*
|
||||
* ptnetmap configuration
|
||||
@ -115,18 +113,17 @@ ptnetmap_write_cfg(struct nmreq *nmr, struct ptnetmap_cfg *cfg)
|
||||
#define PTNET_IO_PTFEAT 0
|
||||
#define PTNET_IO_PTCTL 4
|
||||
#define PTNET_IO_PTSTS 8
|
||||
/* hole */
|
||||
#define PTNET_IO_MAC_LO 16
|
||||
#define PTNET_IO_MAC_HI 20
|
||||
#define PTNET_IO_CSBBAH 24
|
||||
#define PTNET_IO_CSBBAL 28
|
||||
#define PTNET_IO_NIFP_OFS 32
|
||||
#define PTNET_IO_NUM_TX_RINGS 36
|
||||
#define PTNET_IO_NUM_RX_RINGS 40
|
||||
#define PTNET_IO_NUM_TX_SLOTS 44
|
||||
#define PTNET_IO_NUM_RX_SLOTS 48
|
||||
#define PTNET_IO_VNET_HDR_LEN 52
|
||||
#define PTNET_IO_END 56
|
||||
#define PTNET_IO_MAC_LO 12
|
||||
#define PTNET_IO_MAC_HI 16
|
||||
#define PTNET_IO_CSBBAH 20
|
||||
#define PTNET_IO_CSBBAL 24
|
||||
#define PTNET_IO_NIFP_OFS 28
|
||||
#define PTNET_IO_NUM_TX_RINGS 32
|
||||
#define PTNET_IO_NUM_RX_RINGS 36
|
||||
#define PTNET_IO_NUM_TX_SLOTS 40
|
||||
#define PTNET_IO_NUM_RX_SLOTS 44
|
||||
#define PTNET_IO_VNET_HDR_LEN 48
|
||||
#define PTNET_IO_END 52
|
||||
#define PTNET_IO_KICK_BASE 128
|
||||
#define PTNET_IO_MASK 0xff
|
||||
|
||||
@ -139,11 +136,11 @@ struct ptnet_ring {
|
||||
uint32_t head; /* GW+ HR+ the head of the guest netmap_ring */
|
||||
uint32_t cur; /* GW+ HR+ the cur of the guest netmap_ring */
|
||||
uint32_t guest_need_kick; /* GW+ HR+ host-->guest notification enable */
|
||||
char pad[4];
|
||||
uint32_t sync_flags; /* GW+ HR+ the flags of the guest [tx|rx]sync() */
|
||||
uint32_t hwcur; /* GR+ HW+ the hwcur of the host netmap_kring */
|
||||
uint32_t hwtail; /* GR+ HW+ the hwtail of the host netmap_kring */
|
||||
uint32_t host_need_kick; /* GR+ HW+ guest-->host notification enable */
|
||||
uint32_t sync_flags; /* GW+ HR+ the flags of the guest [tx|rx]sync() */
|
||||
char pad[4];
|
||||
};
|
||||
|
||||
/* CSB for the ptnet device. */
|
||||
@ -165,6 +162,61 @@ ptn_sub(uint32_t l_elem, uint32_t r_elem, uint32_t num_slots)
|
||||
}
|
||||
#endif /* WITH_PTNETMAP_HOST || WITH_PTNETMAP_GUEST */
|
||||
|
||||
#ifdef WITH_PTNETMAP_GUEST
|
||||
|
||||
/* ptnetmap_memdev routines used to talk with ptnetmap_memdev device driver */
|
||||
struct ptnetmap_memdev;
|
||||
int nm_os_pt_memdev_iomap(struct ptnetmap_memdev *, vm_paddr_t *, void **);
|
||||
void nm_os_pt_memdev_iounmap(struct ptnetmap_memdev *);
|
||||
|
||||
/* Guest driver: Write kring pointers (cur, head) to the CSB.
|
||||
* This routine is coupled with ptnetmap_host_read_kring_csb(). */
|
||||
static inline void
|
||||
ptnetmap_guest_write_kring_csb(struct ptnet_ring *ptr, uint32_t cur,
|
||||
uint32_t head)
|
||||
{
|
||||
/*
|
||||
* We need to write cur and head to the CSB but we cannot do it atomically.
|
||||
* There is no way we can prevent the host from reading the updated value
|
||||
* of one of the two and the old value of the other. However, if we make
|
||||
* sure that the host never reads a value of head more recent than the
|
||||
* value of cur we are safe. We can allow the host to read a value of cur
|
||||
* more recent than the value of head, since in the netmap ring cur can be
|
||||
* ahead of head and cur cannot wrap around head because it must be behind
|
||||
* tail. Inverting the order of writes below could instead result into the
|
||||
* host to think head went ahead of cur, which would cause the sync
|
||||
* prologue to fail.
|
||||
*
|
||||
* The following memory barrier scheme is used to make this happen:
|
||||
*
|
||||
* Guest Host
|
||||
*
|
||||
* STORE(cur) LOAD(head)
|
||||
* mb() <-----------> mb()
|
||||
* STORE(head) LOAD(cur)
|
||||
*/
|
||||
ptr->cur = cur;
|
||||
mb();
|
||||
ptr->head = head;
|
||||
}
|
||||
|
||||
/* Guest driver: Read kring pointers (hwcur, hwtail) from the CSB.
|
||||
* This routine is coupled with ptnetmap_host_write_kring_csb(). */
|
||||
static inline void
|
||||
ptnetmap_guest_read_kring_csb(struct ptnet_ring *ptr, struct netmap_kring *kring)
|
||||
{
|
||||
/*
|
||||
* We place a memory barrier to make sure that the update of hwtail never
|
||||
* overtakes the update of hwcur.
|
||||
* (see explanation in ptnetmap_host_write_kring_csb).
|
||||
*/
|
||||
kring->nr_hwtail = ptr->hwtail;
|
||||
mb();
|
||||
kring->nr_hwcur = ptr->hwcur;
|
||||
}
|
||||
|
||||
#endif /* WITH_PTNETMAP_GUEST */
|
||||
|
||||
#ifdef WITH_PTNETMAP_HOST
|
||||
/*
|
||||
* ptnetmap kernel thread routines
|
||||
@ -179,147 +231,50 @@ ptn_sub(uint32_t l_elem, uint32_t r_elem, uint32_t num_slots)
|
||||
#define CSB_WRITE(csb, field, v) (suword32(&csb->field, v))
|
||||
#endif /* ! linux */
|
||||
|
||||
/*
|
||||
* HOST read/write kring pointers from/in CSB
|
||||
*/
|
||||
|
||||
/* Host: Read kring pointers (head, cur, sync_flags) from CSB */
|
||||
static inline void
|
||||
ptnetmap_host_read_kring_csb(struct ptnet_ring __user *ptr,
|
||||
struct netmap_ring *g_ring,
|
||||
uint32_t num_slots)
|
||||
{
|
||||
uint32_t old_head = g_ring->head, old_cur = g_ring->cur;
|
||||
uint32_t d, inc_h, inc_c;
|
||||
|
||||
//mb(); /* Force memory complete before read CSB */
|
||||
|
||||
/*
|
||||
* We must first read head and then cur with a barrier in the
|
||||
* middle, because cur can exceed head, but not vice versa.
|
||||
* The guest must first write cur and then head with a barrier.
|
||||
*
|
||||
* head <= cur
|
||||
*
|
||||
* guest host
|
||||
*
|
||||
* STORE(cur) LOAD(head)
|
||||
* mb() ----------- mb()
|
||||
* STORE(head) LOAD(cur)
|
||||
*
|
||||
* This approach ensures that every head that we read is
|
||||
* associated with the correct cur. In this way head can not exceed cur.
|
||||
*/
|
||||
CSB_READ(ptr, head, g_ring->head);
|
||||
mb();
|
||||
CSB_READ(ptr, cur, g_ring->cur);
|
||||
CSB_READ(ptr, sync_flags, g_ring->flags);
|
||||
|
||||
/*
|
||||
* Even with the previous barrier, it is still possible that we read an
|
||||
* updated cur and an old head.
|
||||
* To detect this situation, we can check if the new cur overtakes
|
||||
* the (apparently) new head.
|
||||
*/
|
||||
d = ptn_sub(old_cur, old_head, num_slots); /* previous distance */
|
||||
inc_c = ptn_sub(g_ring->cur, old_cur, num_slots); /* increase of cur */
|
||||
inc_h = ptn_sub(g_ring->head, old_head, num_slots); /* increase of head */
|
||||
|
||||
if (unlikely(inc_c > num_slots - d + inc_h)) { /* cur overtakes head */
|
||||
ND(1,"ERROR cur overtakes head - old_cur: %u cur: %u old_head: %u head: %u",
|
||||
old_cur, g_ring->cur, old_head, g_ring->head);
|
||||
g_ring->cur = nm_prev(g_ring->head, num_slots - 1);
|
||||
//*g_cur = *g_head;
|
||||
}
|
||||
}
|
||||
|
||||
/* Host: Write kring pointers (hwcur, hwtail) into the CSB */
|
||||
/* Host netmap: Write kring pointers (hwcur, hwtail) to the CSB.
|
||||
* This routine is coupled with ptnetmap_guest_read_kring_csb(). */
|
||||
static inline void
|
||||
ptnetmap_host_write_kring_csb(struct ptnet_ring __user *ptr, uint32_t hwcur,
|
||||
uint32_t hwtail)
|
||||
{
|
||||
/* We must write hwtail before hwcur (see below). */
|
||||
CSB_WRITE(ptr, hwtail, hwtail);
|
||||
mb();
|
||||
/*
|
||||
* The same scheme used in ptnetmap_guest_write_kring_csb() applies here.
|
||||
* We allow the guest to read a value of hwcur more recent than the value
|
||||
* of hwtail, since this would anyway result in a consistent view of the
|
||||
* ring state (and hwcur can never wraparound hwtail, since hwcur must be
|
||||
* behind head).
|
||||
*
|
||||
* The following memory barrier scheme is used to make this happen:
|
||||
*
|
||||
* Guest Host
|
||||
*
|
||||
* STORE(hwcur) LOAD(hwtail)
|
||||
* mb() <-------------> mb()
|
||||
* STORE(hwtail) LOAD(hwcur)
|
||||
*/
|
||||
CSB_WRITE(ptr, hwcur, hwcur);
|
||||
mb();
|
||||
CSB_WRITE(ptr, hwtail, hwtail);
|
||||
}
|
||||
|
||||
//mb(); /* Force memory complete before send notification */
|
||||
/* Host netmap: Read kring pointers (head, cur, sync_flags) from the CSB.
|
||||
* This routine is coupled with ptnetmap_guest_write_kring_csb(). */
|
||||
static inline void
|
||||
ptnetmap_host_read_kring_csb(struct ptnet_ring __user *ptr,
|
||||
struct netmap_ring *shadow_ring,
|
||||
uint32_t num_slots)
|
||||
{
|
||||
/*
|
||||
* We place a memory barrier to make sure that the update of head never
|
||||
* overtakes the update of cur.
|
||||
* (see explanation in ptnetmap_guest_write_kring_csb).
|
||||
*/
|
||||
CSB_READ(ptr, head, shadow_ring->head);
|
||||
mb();
|
||||
CSB_READ(ptr, cur, shadow_ring->cur);
|
||||
CSB_READ(ptr, sync_flags, shadow_ring->flags);
|
||||
}
|
||||
|
||||
#endif /* WITH_PTNETMAP_HOST */
|
||||
|
||||
#ifdef WITH_PTNETMAP_GUEST
|
||||
/*
|
||||
* GUEST read/write kring pointers from/in CSB.
|
||||
* To use into device driver.
|
||||
*/
|
||||
|
||||
/* Guest: Write kring pointers (cur, head) into the CSB */
|
||||
static inline void
|
||||
ptnetmap_guest_write_kring_csb(struct ptnet_ring *ptr, uint32_t cur,
|
||||
uint32_t head)
|
||||
{
|
||||
/* We must write cur before head for sync reason (see above) */
|
||||
ptr->cur = cur;
|
||||
mb();
|
||||
ptr->head = head;
|
||||
|
||||
//mb(); /* Force memory complete before send notification */
|
||||
}
|
||||
|
||||
/* Guest: Read kring pointers (hwcur, hwtail) from CSB */
|
||||
static inline void
|
||||
ptnetmap_guest_read_kring_csb(struct ptnet_ring *ptr, struct netmap_kring *kring)
|
||||
{
|
||||
uint32_t old_hwcur = kring->nr_hwcur, old_hwtail = kring->nr_hwtail;
|
||||
uint32_t num_slots = kring->nkr_num_slots;
|
||||
uint32_t d, inc_hc, inc_ht;
|
||||
|
||||
//mb(); /* Force memory complete before read CSB */
|
||||
|
||||
/*
|
||||
* We must first read hwcur and then hwtail with a barrier in the
|
||||
* middle, because hwtail can exceed hwcur, but not vice versa.
|
||||
* The host must first write hwtail and then hwcur with a barrier.
|
||||
*
|
||||
* hwcur <= hwtail
|
||||
*
|
||||
* host guest
|
||||
*
|
||||
* STORE(hwtail) LOAD(hwcur)
|
||||
* mb() --------- mb()
|
||||
* STORE(hwcur) LOAD(hwtail)
|
||||
*
|
||||
* This approach ensures that every hwcur that the guest reads is
|
||||
* associated with the correct hwtail. In this way hwcur can not exceed
|
||||
* hwtail.
|
||||
*/
|
||||
kring->nr_hwcur = ptr->hwcur;
|
||||
mb();
|
||||
kring->nr_hwtail = ptr->hwtail;
|
||||
|
||||
/*
|
||||
* Even with the previous barrier, it is still possible that we read an
|
||||
* updated hwtail and an old hwcur.
|
||||
* To detect this situation, we can check if the new hwtail overtakes
|
||||
* the (apparently) new hwcur.
|
||||
*/
|
||||
d = ptn_sub(old_hwtail, old_hwcur, num_slots); /* previous distance */
|
||||
inc_ht = ptn_sub(kring->nr_hwtail, old_hwtail, num_slots); /* increase of hwtail */
|
||||
inc_hc = ptn_sub(kring->nr_hwcur, old_hwcur, num_slots); /* increase of hwcur */
|
||||
|
||||
if (unlikely(inc_ht > num_slots - d + inc_hc)) {
|
||||
ND(1, "ERROR hwtail overtakes hwcur - old_hwtail: %u hwtail: %u old_hwcur: %u hwcur: %u",
|
||||
old_hwtail, kring->nr_hwtail, old_hwcur, kring->nr_hwcur);
|
||||
kring->nr_hwtail = nm_prev(kring->nr_hwcur, num_slots - 1);
|
||||
//kring->nr_hwtail = kring->nr_hwcur;
|
||||
}
|
||||
}
|
||||
|
||||
/* ptnetmap_memdev routines used to talk with ptnetmap_memdev device driver */
|
||||
struct ptnetmap_memdev;
|
||||
int nm_os_pt_memdev_iomap(struct ptnetmap_memdev *, vm_paddr_t *, void **);
|
||||
void nm_os_pt_memdev_iounmap(struct ptnetmap_memdev *);
|
||||
#endif /* WITH_PTNETMAP_GUEST */
|
||||
|
||||
#endif /* NETMAP_VIRT_H */
|
||||
|
Loading…
Reference in New Issue
Block a user