svn commit: r302484 - in head/sys: conf dev/ntb dev/ntb/if_ntb dev/ntb/ntb_hw modules/ntb modules/ntb/ntb modules/ntb/ntb_hw modules/ntb/ntb_transport
Alexander Motin
mav at FreeBSD.org
Sat Jul 9 11:20:44 UTC 2016
Author: mav
Date: Sat Jul 9 11:20:42 2016
New Revision: 302484
URL: https://svnweb.freebsd.org/changeset/base/302484
Log:
NewBus'ify NTB subsystem.
This follows NTB subsystem modularization in Linux, tuning it to FreeBSD
native NewBus interfaces. This change allows to support different types
of hardware with different drivers, support multiple NTB instances in a
system, ntb_transport module use for needs other then if_ntb, etc.
Sponsored by: iXsystems, Inc.
Added:
head/sys/dev/ntb/ntb.c (contents, props changed)
head/sys/dev/ntb/ntb.h (contents, props changed)
head/sys/dev/ntb/ntb_if.m (contents, props changed)
head/sys/dev/ntb/ntb_transport.c
- copied, changed from r302483, head/sys/dev/ntb/if_ntb/if_ntb.c
head/sys/dev/ntb/ntb_transport.h (contents, props changed)
head/sys/modules/ntb/ntb/
head/sys/modules/ntb/ntb/Makefile (contents, props changed)
head/sys/modules/ntb/ntb_transport/
head/sys/modules/ntb/ntb_transport/Makefile (contents, props changed)
Deleted:
head/sys/dev/ntb/ntb_hw/ntb_hw.h
Modified:
head/sys/conf/files.amd64
head/sys/conf/files.i386
head/sys/dev/ntb/if_ntb/if_ntb.c
head/sys/dev/ntb/ntb_hw/ntb_hw.c
head/sys/dev/ntb/ntb_hw/ntb_regs.h
head/sys/modules/ntb/Makefile
head/sys/modules/ntb/ntb_hw/Makefile
Modified: head/sys/conf/files.amd64
==============================================================================
--- head/sys/conf/files.amd64 Sat Jul 9 09:47:11 2016 (r302483)
+++ head/sys/conf/files.amd64 Sat Jul 9 11:20:42 2016 (r302484)
@@ -282,7 +282,10 @@ dev/hyperv/vmbus/amd64/hyperv_machdep.c
dev/hyperv/vmbus/amd64/vmbus_vector.S optional hyperv
dev/nfe/if_nfe.c optional nfe pci
dev/ntb/if_ntb/if_ntb.c optional if_ntb
-dev/ntb/ntb_hw/ntb_hw.c optional if_ntb | ntb_hw
+dev/ntb/ntb_transport.c optional if_ntb
+dev/ntb/ntb.c optional if_ntb | ntb_hw
+dev/ntb/ntb_if.m optional if_ntb | ntb_hw
+dev/ntb/ntb_hw/ntb_hw.c optional ntb_hw
dev/nvd/nvd.c optional nvd nvme
dev/nvme/nvme.c optional nvme
dev/nvme/nvme_ctrlr.c optional nvme
Modified: head/sys/conf/files.i386
==============================================================================
--- head/sys/conf/files.i386 Sat Jul 9 09:47:11 2016 (r302483)
+++ head/sys/conf/files.i386 Sat Jul 9 11:20:42 2016 (r302484)
@@ -276,7 +276,10 @@ dev/mse/mse.c optional mse
dev/mse/mse_isa.c optional mse isa
dev/nfe/if_nfe.c optional nfe pci
dev/ntb/if_ntb/if_ntb.c optional if_ntb
-dev/ntb/ntb_hw/ntb_hw.c optional if_ntb | ntb_hw
+dev/ntb/ntb_transport.c optional if_ntb
+dev/ntb/ntb.c optional if_ntb | ntb_hw
+dev/ntb/ntb_if.m optional if_ntb | ntb_hw
+dev/ntb/ntb_hw/ntb_hw.c optional ntb_hw
dev/nvd/nvd.c optional nvd nvme
dev/nvme/nvme.c optional nvme
dev/nvme/nvme_ctrlr.c optional nvme
Modified: head/sys/dev/ntb/if_ntb/if_ntb.c
==============================================================================
--- head/sys/dev/ntb/if_ntb/if_ntb.c Sat Jul 9 09:47:11 2016 (r302483)
+++ head/sys/dev/ntb/if_ntb/if_ntb.c Sat Jul 9 11:20:42 2016 (r302484)
@@ -1,4 +1,5 @@
/*-
+ * Copyright (c) 2016 Alexander Motin <mav at FreeBSD.org>
* Copyright (C) 2013 Intel Corporation
* Copyright (C) 2015 EMC Corporation
* All rights reserved.
@@ -25,25 +26,28 @@
* SUCH DAMAGE.
*/
+/*
+ * The Non-Transparent Bridge (NTB) is a device that allows you to connect
+ * two or more systems using a PCI-e links, providing remote memory access.
+ *
+ * This module contains a driver for simulated Ethernet device, using
+ * underlying NTB Transport device.
+ *
+ * NOTE: Much of the code in this module is shared with Linux. Any patches may
+ * be picked up and redistributed in Linux with a dual GPL/BSD license.
+ */
+
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
-#include <sys/bitset.h>
#include <sys/bus.h>
-#include <sys/ktr.h>
#include <sys/limits.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
#include <sys/module.h>
-#include <sys/mutex.h>
-#include <sys/queue.h>
#include <sys/socket.h>
#include <sys/sockio.h>
-#include <sys/sysctl.h>
-#include <sys/taskqueue.h>
#include <net/if.h>
#include <net/if_media.h>
@@ -52,249 +56,24 @@ __FBSDID("$FreeBSD$");
#include <net/bpf.h>
#include <net/ethernet.h>
-#include <vm/vm.h>
-#include <vm/pmap.h>
-
#include <machine/bus.h>
-#include <machine/cpufunc.h>
-
-#include <netinet/in.h>
-#include <netinet/ip.h>
-#include "../ntb_hw/ntb_hw.h"
-
-/*
- * The Non-Transparent Bridge (NTB) is a device on some Intel processors that
- * allows you to connect two systems using a PCI-e link.
- *
- * This module contains a protocol for sending and receiving messages, and
- * exposes that protocol through a simulated ethernet device called ntb.
- *
- * NOTE: Much of the code in this module is shared with Linux. Any patches may
- * be picked up and redistributed in Linux with a dual GPL/BSD license.
- */
-
-#define QP_SETSIZE 64
-BITSET_DEFINE(_qpset, QP_SETSIZE);
-#define test_bit(pos, addr) BIT_ISSET(QP_SETSIZE, (pos), (addr))
-#define set_bit(pos, addr) BIT_SET(QP_SETSIZE, (pos), (addr))
-#define clear_bit(pos, addr) BIT_CLR(QP_SETSIZE, (pos), (addr))
-#define ffs_bit(addr) BIT_FFS(QP_SETSIZE, (addr))
+#include "../ntb_transport.h"
#define KTR_NTB KTR_SPARE3
-#define NTB_TRANSPORT_VERSION 4
-#define NTB_RX_MAX_PKTS 64
-#define NTB_RXQ_SIZE 300
-
-enum ntb_link_event {
- NTB_LINK_DOWN = 0,
- NTB_LINK_UP,
-};
-
-static SYSCTL_NODE(_hw, OID_AUTO, if_ntb, CTLFLAG_RW, 0, "if_ntb");
-
-static unsigned g_if_ntb_debug_level;
-SYSCTL_UINT(_hw_if_ntb, OID_AUTO, debug_level, CTLFLAG_RWTUN,
- &g_if_ntb_debug_level, 0, "if_ntb log level -- higher is more verbose");
-#define ntb_printf(lvl, ...) do { \
- if ((lvl) <= g_if_ntb_debug_level) { \
- if_printf(nt->ifp, __VA_ARGS__); \
- } \
-} while (0)
-
-static unsigned transport_mtu = IP_MAXPACKET + ETHER_HDR_LEN + ETHER_CRC_LEN;
-
-static uint64_t max_mw_size;
-SYSCTL_UQUAD(_hw_if_ntb, OID_AUTO, max_mw_size, CTLFLAG_RDTUN, &max_mw_size, 0,
- "If enabled (non-zero), limit the size of large memory windows. "
- "Both sides of the NTB MUST set the same value here.");
-
-static unsigned max_num_clients;
-SYSCTL_UINT(_hw_if_ntb, OID_AUTO, max_num_clients, CTLFLAG_RDTUN,
- &max_num_clients, 0, "Maximum number of NTB transport clients. "
- "0 (default) - use all available NTB memory windows; "
- "positive integer N - Limit to N memory windows.");
-
-static unsigned enable_xeon_watchdog;
-SYSCTL_UINT(_hw_if_ntb, OID_AUTO, enable_xeon_watchdog, CTLFLAG_RDTUN,
- &enable_xeon_watchdog, 0, "If non-zero, write a register every second to "
- "keep a watchdog from tearing down the NTB link");
-
-STAILQ_HEAD(ntb_queue_list, ntb_queue_entry);
-
-typedef uint32_t ntb_q_idx_t;
-
-struct ntb_queue_entry {
- /* ntb_queue list reference */
- STAILQ_ENTRY(ntb_queue_entry) entry;
-
- /* info on data to be transferred */
- void *cb_data;
- void *buf;
- uint32_t len;
- uint32_t flags;
-
- struct ntb_transport_qp *qp;
- struct ntb_payload_header *x_hdr;
- ntb_q_idx_t index;
-};
-
-struct ntb_rx_info {
- ntb_q_idx_t entry;
-};
-
-struct ntb_transport_qp {
- struct ntb_transport_ctx *transport;
- struct ntb_softc *ntb;
-
- void *cb_data;
-
- bool client_ready;
- volatile bool link_is_up;
- uint8_t qp_num; /* Only 64 QPs are allowed. 0-63 */
-
- struct ntb_rx_info *rx_info;
- struct ntb_rx_info *remote_rx_info;
-
- void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
- void *data, int len);
- struct ntb_queue_list tx_free_q;
- struct mtx ntb_tx_free_q_lock;
- caddr_t tx_mw;
- bus_addr_t tx_mw_phys;
- ntb_q_idx_t tx_index;
- ntb_q_idx_t tx_max_entry;
- uint64_t tx_max_frame;
-
- void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
- void *data, int len);
- struct ntb_queue_list rx_post_q;
- struct ntb_queue_list rx_pend_q;
- /* ntb_rx_q_lock: synchronize access to rx_XXXX_q */
- struct mtx ntb_rx_q_lock;
- struct task rx_completion_task;
- struct task rxc_db_work;
- caddr_t rx_buff;
- ntb_q_idx_t rx_index;
- ntb_q_idx_t rx_max_entry;
- uint64_t rx_max_frame;
-
- void (*event_handler)(void *data, enum ntb_link_event status);
- struct callout link_work;
- struct callout queue_full;
- struct callout rx_full;
-
- uint64_t last_rx_no_buf;
-
- /* Stats */
- uint64_t rx_bytes;
- uint64_t rx_pkts;
- uint64_t rx_ring_empty;
- uint64_t rx_err_no_buf;
- uint64_t rx_err_oflow;
- uint64_t rx_err_ver;
- uint64_t tx_bytes;
- uint64_t tx_pkts;
- uint64_t tx_ring_full;
- uint64_t tx_err_no_buf;
-};
-
-struct ntb_queue_handlers {
- void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
- void *data, int len);
- void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
- void *data, int len);
- void (*event_handler)(void *data, enum ntb_link_event status);
-};
-
-struct ntb_transport_mw {
- vm_paddr_t phys_addr;
- size_t phys_size;
- size_t xlat_align;
- size_t xlat_align_size;
- bus_addr_t addr_limit;
- /* Tx buff is off vbase / phys_addr */
- caddr_t vbase;
- size_t xlat_size;
- size_t buff_size;
- /* Rx buff is off virt_addr / dma_addr */
- caddr_t virt_addr;
- bus_addr_t dma_addr;
-};
-
-struct ntb_transport_ctx {
- struct ntb_softc *ntb;
+struct ntb_net_ctx {
+ device_t *dev;
struct ifnet *ifp;
- struct ntb_transport_mw mw_vec[NTB_MAX_NUM_MW];
- struct ntb_transport_qp *qp_vec;
- struct _qpset qp_bitmap;
- struct _qpset qp_bitmap_free;
- unsigned mw_count;
- unsigned qp_count;
- volatile bool link_is_up;
- struct callout link_work;
- struct callout link_watchdog;
- struct task link_cleanup;
- uint64_t bufsize;
+ struct ntb_transport_qp *qp;
u_char eaddr[ETHER_ADDR_LEN];
struct mtx tx_lock;
- struct mtx rx_lock;
-
- /* The hardcoded single queuepair in ntb_setup_interface() */
- struct ntb_transport_qp *qp;
-};
-
-static struct ntb_transport_ctx net_softc;
-
-enum {
- IF_NTB_DESC_DONE_FLAG = 1 << 0,
- IF_NTB_LINK_DOWN_FLAG = 1 << 1,
-};
-
-struct ntb_payload_header {
- ntb_q_idx_t ver;
- uint32_t len;
- uint32_t flags;
-};
-
-enum {
- /*
- * The order of this enum is part of the if_ntb remote protocol. Do
- * not reorder without bumping protocol version (and it's probably best
- * to keep the protocol in lock-step with the Linux NTB driver.
- */
- IF_NTB_VERSION = 0,
- IF_NTB_QP_LINKS,
- IF_NTB_NUM_QPS,
- IF_NTB_NUM_MWS,
- /*
- * N.B.: transport_link_work assumes MW1 enums = MW0 + 2.
- */
- IF_NTB_MW0_SZ_HIGH,
- IF_NTB_MW0_SZ_LOW,
- IF_NTB_MW1_SZ_HIGH,
- IF_NTB_MW1_SZ_LOW,
- IF_NTB_MAX_SPAD,
-
- /*
- * Some NTB-using hardware have a watchdog to work around NTB hangs; if
- * a register or doorbell isn't written every few seconds, the link is
- * torn down. Write an otherwise unused register every few seconds to
- * work around this watchdog.
- */
- IF_NTB_WATCHDOG_SPAD = 15
+ struct callout queue_full;
};
-CTASSERT(IF_NTB_WATCHDOG_SPAD < XEON_SPAD_COUNT &&
- IF_NTB_WATCHDOG_SPAD < ATOM_SPAD_COUNT);
-#define QP_TO_MW(nt, qp) ((qp) % nt->mw_count)
-#define NTB_QP_DEF_NUM_ENTRIES 100
-#define NTB_LINK_DOWN_TIMEOUT 10
-
-static int ntb_handle_module_events(struct module *m, int what, void *arg);
-static int ntb_setup_interface(void);
-static int ntb_teardown_interface(void);
+static int ntb_net_probe(device_t dev);
+static int ntb_net_attach(device_t dev);
+static int ntb_net_detach(device_t dev);
static void ntb_net_init(void *arg);
static int ntb_ioctl(struct ifnet *ifp, u_long command, caddr_t data);
static void ntb_start(struct ifnet *ifp);
@@ -303,165 +82,72 @@ static void ntb_net_tx_handler(struct nt
static void ntb_net_rx_handler(struct ntb_transport_qp *qp, void *qp_data,
void *data, int len);
static void ntb_net_event_handler(void *data, enum ntb_link_event status);
-static int ntb_transport_probe(struct ntb_softc *ntb);
-static void ntb_transport_free(struct ntb_transport_ctx *);
-static void ntb_transport_init_queue(struct ntb_transport_ctx *nt,
- unsigned int qp_num);
-static void ntb_transport_free_queue(struct ntb_transport_qp *qp);
-static struct ntb_transport_qp *ntb_transport_create_queue(void *data,
- struct ntb_softc *pdev, const struct ntb_queue_handlers *handlers);
-static void ntb_transport_link_up(struct ntb_transport_qp *qp);
-static int ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb,
- void *data, unsigned int len);
-static int ntb_process_tx(struct ntb_transport_qp *qp,
- struct ntb_queue_entry *entry);
-static void ntb_memcpy_tx(struct ntb_transport_qp *qp,
- struct ntb_queue_entry *entry, void *offset);
static void ntb_qp_full(void *arg);
-static void ntb_transport_rxc_db(void *arg, int pending);
-static int ntb_process_rxc(struct ntb_transport_qp *qp);
-static void ntb_memcpy_rx(struct ntb_transport_qp *qp,
- struct ntb_queue_entry *entry, void *offset);
-static inline void ntb_rx_copy_callback(struct ntb_transport_qp *qp,
- void *data);
-static void ntb_complete_rxc(void *arg, int pending);
-static void ntb_transport_doorbell_callback(void *data, uint32_t vector);
-static void ntb_transport_event_callback(void *data);
-static void ntb_transport_link_work(void *arg);
-static int ntb_set_mw(struct ntb_transport_ctx *, int num_mw, size_t size);
-static void ntb_free_mw(struct ntb_transport_ctx *nt, int num_mw);
-static int ntb_transport_setup_qp_mw(struct ntb_transport_ctx *nt,
- unsigned int qp_num);
-static void ntb_qp_link_work(void *arg);
-static void ntb_transport_link_cleanup(struct ntb_transport_ctx *nt);
-static void ntb_transport_link_cleanup_work(void *, int);
-static void ntb_qp_link_down(struct ntb_transport_qp *qp);
-static void ntb_qp_link_down_reset(struct ntb_transport_qp *qp);
-static void ntb_qp_link_cleanup(struct ntb_transport_qp *qp);
-static void ntb_transport_link_down(struct ntb_transport_qp *qp);
-static void ntb_send_link_down(struct ntb_transport_qp *qp);
-static void ntb_list_add(struct mtx *lock, struct ntb_queue_entry *entry,
- struct ntb_queue_list *list);
-static struct ntb_queue_entry *ntb_list_rm(struct mtx *lock,
- struct ntb_queue_list *list);
-static struct ntb_queue_entry *ntb_list_mv(struct mtx *lock,
- struct ntb_queue_list *from, struct ntb_queue_list *to);
static void create_random_local_eui48(u_char *eaddr);
-static unsigned int ntb_transport_max_size(struct ntb_transport_qp *qp);
-static void xeon_link_watchdog_hb(void *);
-
-static const struct ntb_ctx_ops ntb_transport_ops = {
- .link_event = ntb_transport_event_callback,
- .db_event = ntb_transport_doorbell_callback,
-};
-
-MALLOC_DEFINE(M_NTB_IF, "if_ntb", "ntb network driver");
-
-static inline void
-iowrite32(uint32_t val, void *addr)
-{
-
- bus_space_write_4(X86_BUS_SPACE_MEM, 0/* HACK */, (uintptr_t)addr,
- val);
-}
-/* Module setup and teardown */
static int
-ntb_handle_module_events(struct module *m, int what, void *arg)
+ntb_net_probe(device_t dev)
{
- int err = 0;
- switch (what) {
- case MOD_LOAD:
- err = ntb_setup_interface();
- break;
- case MOD_UNLOAD:
- err = ntb_teardown_interface();
- break;
- default:
- err = EOPNOTSUPP;
- break;
- }
- return (err);
+ device_set_desc(dev, "NTB Network Interface");
+ return (0);
}
-static moduledata_t if_ntb_mod = {
- "if_ntb",
- ntb_handle_module_events,
- NULL
-};
-
-DECLARE_MODULE(if_ntb, if_ntb_mod, SI_SUB_KLD, SI_ORDER_ANY);
-MODULE_DEPEND(if_ntb, ntb_hw, 1, 1, 1);
-
static int
-ntb_setup_interface(void)
+ntb_net_attach(device_t dev)
{
+ struct ntb_net_ctx *sc = device_get_softc(dev);
struct ifnet *ifp;
struct ntb_queue_handlers handlers = { ntb_net_rx_handler,
ntb_net_tx_handler, ntb_net_event_handler };
- int rc;
- net_softc.ntb = devclass_get_softc(devclass_find("ntb_hw"), 0);
- if (net_softc.ntb == NULL) {
- printf("ntb: Cannot find devclass\n");
- return (ENXIO);
- }
-
- ifp = net_softc.ifp = if_alloc(IFT_ETHER);
+ ifp = sc->ifp = if_alloc(IFT_ETHER);
if (ifp == NULL) {
- ntb_transport_free(&net_softc);
printf("ntb: Cannot allocate ifnet structure\n");
return (ENOMEM);
}
- if_initname(ifp, "ntb", 0);
+ if_initname(ifp, device_get_name(dev), device_get_unit(dev));
- rc = ntb_transport_probe(net_softc.ntb);
- if (rc != 0) {
- printf("ntb: Cannot init transport: %d\n", rc);
- if_free(net_softc.ifp);
- return (rc);
- }
+ mtx_init(&sc->tx_lock, "ntb tx", NULL, MTX_DEF);
+ callout_init(&sc->queue_full, 1);
- net_softc.qp = ntb_transport_create_queue(ifp, net_softc.ntb,
+ sc->qp = ntb_transport_create_queue(ifp, device_get_parent(dev),
&handlers);
ifp->if_init = ntb_net_init;
- ifp->if_softc = &net_softc;
+ ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = ntb_ioctl;
ifp->if_start = ntb_start;
IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
IFQ_SET_READY(&ifp->if_snd);
- create_random_local_eui48(net_softc.eaddr);
- ether_ifattach(ifp, net_softc.eaddr);
+ create_random_local_eui48(sc->eaddr);
+ ether_ifattach(ifp, sc->eaddr);
ifp->if_capabilities = IFCAP_HWCSUM | IFCAP_JUMBO_MTU;
ifp->if_capenable = ifp->if_capabilities;
- ifp->if_mtu = ntb_transport_max_size(net_softc.qp) - ETHER_HDR_LEN -
+ ifp->if_mtu = ntb_transport_max_size(sc->qp) - ETHER_HDR_LEN -
ETHER_CRC_LEN;
- ntb_transport_link_up(net_softc.qp);
- net_softc.bufsize = ntb_transport_max_size(net_softc.qp) +
- sizeof(struct ether_header);
+ ntb_transport_link_up(sc->qp);
return (0);
}
static int
-ntb_teardown_interface(void)
+ntb_net_detach(device_t dev)
{
+ struct ntb_net_ctx *sc = device_get_softc(dev);
- if (net_softc.qp != NULL) {
- ntb_transport_link_down(net_softc.qp);
-
- ntb_transport_free_queue(net_softc.qp);
- ntb_transport_free(&net_softc);
+ if (sc->qp != NULL) {
+ ntb_transport_link_down(sc->qp);
+ ntb_transport_free_queue(sc->qp);
}
- if (net_softc.ifp != NULL) {
- ether_ifdetach(net_softc.ifp);
- if_free(net_softc.ifp);
- net_softc.ifp = NULL;
+ if (sc->ifp != NULL) {
+ ether_ifdetach(sc->ifp);
+ if_free(sc->ifp);
+ sc->ifp = NULL;
}
+ mtx_destroy(&sc->tx_lock);
return (0);
}
@@ -471,8 +157,8 @@ ntb_teardown_interface(void)
static void
ntb_net_init(void *arg)
{
- struct ntb_transport_ctx *ntb_softc = arg;
- struct ifnet *ifp = ntb_softc->ifp;
+ struct ntb_net_ctx *sc = arg;
+ struct ifnet *ifp = sc->ifp;
ifp->if_drv_flags |= IFF_DRV_RUNNING;
ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
@@ -483,14 +169,14 @@ ntb_net_init(void *arg)
static int
ntb_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
{
- struct ntb_transport_ctx *nt = ifp->if_softc;
+ struct ntb_net_ctx *sc = ifp->if_softc;
struct ifreq *ifr = (struct ifreq *)data;
int error = 0;
switch (command) {
case SIOCSIFMTU:
{
- if (ifr->ifr_mtu > ntb_transport_max_size(nt->qp) -
+ if (ifr->ifr_mtu > ntb_transport_max_size(sc->qp) -
ETHER_HDR_LEN - ETHER_CRC_LEN) {
error = EINVAL;
break;
@@ -512,16 +198,16 @@ static void
ntb_start(struct ifnet *ifp)
{
struct mbuf *m_head;
- struct ntb_transport_ctx *nt = ifp->if_softc;
+ struct ntb_net_ctx *sc = ifp->if_softc;
int rc;
- mtx_lock(&nt->tx_lock);
+ mtx_lock(&sc->tx_lock);
ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
CTR0(KTR_NTB, "TX: ntb_start");
while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
CTR1(KTR_NTB, "TX: start mbuf %p", m_head);
- rc = ntb_transport_tx_enqueue(nt->qp, m_head, m_head,
+ rc = ntb_transport_tx_enqueue(sc->qp, m_head, m_head,
m_length(m_head, NULL));
if (rc != 0) {
CTR1(KTR_NTB,
@@ -530,14 +216,13 @@ ntb_start(struct ifnet *ifp)
if (rc == EAGAIN) {
ifp->if_drv_flags |= IFF_DRV_OACTIVE;
IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
- callout_reset(&nt->qp->queue_full, hz / 1000,
+ callout_reset(&sc->queue_full, hz / 1000,
ntb_qp_full, ifp);
}
break;
}
-
}
- mtx_unlock(&nt->tx_lock);
+ mtx_unlock(&sc->tx_lock);
}
/* Network Device Callbacks */
@@ -558,6 +243,7 @@ ntb_net_rx_handler(struct ntb_transport_
struct ifnet *ifp = qp_data;
CTR0(KTR_NTB, "RX: rx handler");
+ m->m_pkthdr.csum_flags = CSUM_IP_CHECKED | CSUM_IP_VALID;
(*ifp->if_input)(ifp, m);
}
@@ -581,444 +267,6 @@ ntb_net_event_handler(void *data, enum n
}
}
-/* Transport Init and teardown */
-
-static void
-xeon_link_watchdog_hb(void *arg)
-{
- struct ntb_transport_ctx *nt;
-
- nt = arg;
- ntb_spad_write(nt->ntb, IF_NTB_WATCHDOG_SPAD, 0);
- callout_reset(&nt->link_watchdog, 1 * hz, xeon_link_watchdog_hb, nt);
-}
-
-static int
-ntb_transport_probe(struct ntb_softc *ntb)
-{
- struct ntb_transport_ctx *nt = &net_softc;
- struct ntb_transport_mw *mw;
- uint64_t qp_bitmap;
- int rc;
- unsigned i;
-
- nt->mw_count = ntb_mw_count(ntb);
- for (i = 0; i < nt->mw_count; i++) {
- mw = &nt->mw_vec[i];
-
- rc = ntb_mw_get_range(ntb, i, &mw->phys_addr, &mw->vbase,
- &mw->phys_size, &mw->xlat_align, &mw->xlat_align_size,
- &mw->addr_limit);
- if (rc != 0)
- goto err;
-
- mw->buff_size = 0;
- mw->xlat_size = 0;
- mw->virt_addr = NULL;
- mw->dma_addr = 0;
-
- rc = ntb_mw_set_wc(nt->ntb, i, VM_MEMATTR_WRITE_COMBINING);
- if (rc)
- ntb_printf(0, "Unable to set mw%d caching\n", i);
- }
-
- qp_bitmap = ntb_db_valid_mask(ntb);
- nt->qp_count = flsll(qp_bitmap);
- KASSERT(nt->qp_count != 0, ("bogus db bitmap"));
- nt->qp_count -= 1;
-
- if (max_num_clients != 0 && max_num_clients < nt->qp_count)
- nt->qp_count = max_num_clients;
- else if (nt->mw_count < nt->qp_count)
- nt->qp_count = nt->mw_count;
- KASSERT(nt->qp_count <= QP_SETSIZE, ("invalid qp_count"));
-
- mtx_init(&nt->tx_lock, "ntb transport tx", NULL, MTX_DEF);
- mtx_init(&nt->rx_lock, "ntb transport rx", NULL, MTX_DEF);
-
- nt->qp_vec = malloc(nt->qp_count * sizeof(*nt->qp_vec), M_NTB_IF,
- M_WAITOK | M_ZERO);
-
- for (i = 0; i < nt->qp_count; i++) {
- set_bit(i, &nt->qp_bitmap);
- set_bit(i, &nt->qp_bitmap_free);
- ntb_transport_init_queue(nt, i);
- }
-
- callout_init(&nt->link_work, 0);
- callout_init(&nt->link_watchdog, 0);
- TASK_INIT(&nt->link_cleanup, 0, ntb_transport_link_cleanup_work, nt);
-
- rc = ntb_set_ctx(ntb, nt, &ntb_transport_ops);
- if (rc != 0)
- goto err;
-
- nt->link_is_up = false;
- ntb_link_enable(ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
- ntb_link_event(ntb);
-
- callout_reset(&nt->link_work, 0, ntb_transport_link_work, nt);
- if (enable_xeon_watchdog != 0)
- callout_reset(&nt->link_watchdog, 0, xeon_link_watchdog_hb, nt);
- return (0);
-
-err:
- free(nt->qp_vec, M_NTB_IF);
- nt->qp_vec = NULL;
- return (rc);
-}
-
-static void
-ntb_transport_free(struct ntb_transport_ctx *nt)
-{
- struct ntb_softc *ntb = nt->ntb;
- struct _qpset qp_bitmap_alloc;
- uint8_t i;
-
- ntb_transport_link_cleanup(nt);
- taskqueue_drain(taskqueue_swi, &nt->link_cleanup);
- callout_drain(&nt->link_work);
- callout_drain(&nt->link_watchdog);
-
- BIT_COPY(QP_SETSIZE, &nt->qp_bitmap, &qp_bitmap_alloc);
- BIT_NAND(QP_SETSIZE, &qp_bitmap_alloc, &nt->qp_bitmap_free);
-
- /* Verify that all the QPs are freed */
- for (i = 0; i < nt->qp_count; i++)
- if (test_bit(i, &qp_bitmap_alloc))
- ntb_transport_free_queue(&nt->qp_vec[i]);
-
- ntb_link_disable(ntb);
- ntb_clear_ctx(ntb);
-
- for (i = 0; i < nt->mw_count; i++)
- ntb_free_mw(nt, i);
-
- free(nt->qp_vec, M_NTB_IF);
-}
-
-static void
-ntb_transport_init_queue(struct ntb_transport_ctx *nt, unsigned int qp_num)
-{
- struct ntb_transport_mw *mw;
- struct ntb_transport_qp *qp;
- vm_paddr_t mw_base;
- uint64_t mw_size, qp_offset;
- size_t tx_size;
- unsigned num_qps_mw, mw_num, mw_count;
-
- mw_count = nt->mw_count;
- mw_num = QP_TO_MW(nt, qp_num);
- mw = &nt->mw_vec[mw_num];
-
- qp = &nt->qp_vec[qp_num];
- qp->qp_num = qp_num;
- qp->transport = nt;
- qp->ntb = nt->ntb;
- qp->client_ready = false;
- qp->event_handler = NULL;
- ntb_qp_link_down_reset(qp);
-
- if (nt->qp_count % mw_count && mw_num + 1 < nt->qp_count / mw_count)
- num_qps_mw = nt->qp_count / mw_count + 1;
- else
- num_qps_mw = nt->qp_count / mw_count;
-
- mw_base = mw->phys_addr;
- mw_size = mw->phys_size;
-
- tx_size = mw_size / num_qps_mw;
- qp_offset = tx_size * (qp_num / mw_count);
-
- qp->tx_mw = mw->vbase + qp_offset;
- KASSERT(qp->tx_mw != NULL, ("uh oh?"));
-
- /* XXX Assumes that a vm_paddr_t is equivalent to bus_addr_t */
- qp->tx_mw_phys = mw_base + qp_offset;
- KASSERT(qp->tx_mw_phys != 0, ("uh oh?"));
-
- tx_size -= sizeof(struct ntb_rx_info);
- qp->rx_info = (void *)(qp->tx_mw + tx_size);
-
- /* Due to house-keeping, there must be at least 2 buffs */
- qp->tx_max_frame = qmin(tx_size / 2,
- transport_mtu + sizeof(struct ntb_payload_header));
- qp->tx_max_entry = tx_size / qp->tx_max_frame;
-
- callout_init(&qp->link_work, 0);
- callout_init(&qp->queue_full, 1);
- callout_init(&qp->rx_full, 1);
-
- mtx_init(&qp->ntb_rx_q_lock, "ntb rx q", NULL, MTX_SPIN);
- mtx_init(&qp->ntb_tx_free_q_lock, "ntb tx free q", NULL, MTX_SPIN);
- TASK_INIT(&qp->rx_completion_task, 0, ntb_complete_rxc, qp);
- TASK_INIT(&qp->rxc_db_work, 0, ntb_transport_rxc_db, qp);
-
- STAILQ_INIT(&qp->rx_post_q);
- STAILQ_INIT(&qp->rx_pend_q);
- STAILQ_INIT(&qp->tx_free_q);
-
- callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp);
-}
-
-static void
-ntb_transport_free_queue(struct ntb_transport_qp *qp)
-{
- struct ntb_queue_entry *entry;
-
- if (qp == NULL)
- return;
-
- callout_drain(&qp->link_work);
-
- ntb_db_set_mask(qp->ntb, 1ull << qp->qp_num);
- taskqueue_drain(taskqueue_swi, &qp->rxc_db_work);
- taskqueue_drain(taskqueue_swi, &qp->rx_completion_task);
-
- qp->cb_data = NULL;
- qp->rx_handler = NULL;
- qp->tx_handler = NULL;
- qp->event_handler = NULL;
-
- while ((entry = ntb_list_rm(&qp->ntb_rx_q_lock, &qp->rx_pend_q)))
- free(entry, M_NTB_IF);
-
- while ((entry = ntb_list_rm(&qp->ntb_rx_q_lock, &qp->rx_post_q)))
- free(entry, M_NTB_IF);
-
- while ((entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q)))
- free(entry, M_NTB_IF);
-
- set_bit(qp->qp_num, &qp->transport->qp_bitmap_free);
-}
-
-/**
- * ntb_transport_create_queue - Create a new NTB transport layer queue
- * @rx_handler: receive callback function
- * @tx_handler: transmit callback function
- * @event_handler: event callback function
- *
- * Create a new NTB transport layer queue and provide the queue with a callback
- * routine for both transmit and receive. The receive callback routine will be
- * used to pass up data when the transport has received it on the queue. The
- * transmit callback routine will be called when the transport has completed the
- * transmission of the data on the queue and the data is ready to be freed.
- *
- * RETURNS: pointer to newly created ntb_queue, NULL on error.
- */
-static struct ntb_transport_qp *
-ntb_transport_create_queue(void *data, struct ntb_softc *ntb,
- const struct ntb_queue_handlers *handlers)
-{
- struct ntb_queue_entry *entry;
- struct ntb_transport_qp *qp;
- struct ntb_transport_ctx *nt;
- unsigned int free_queue;
- int i;
-
- nt = ntb_get_ctx(ntb, NULL);
- KASSERT(nt != NULL, ("bogus"));
-
- free_queue = ffs_bit(&nt->qp_bitmap);
- if (free_queue == 0)
- return (NULL);
-
- /* decrement free_queue to make it zero based */
- free_queue--;
-
- qp = &nt->qp_vec[free_queue];
- clear_bit(qp->qp_num, &nt->qp_bitmap_free);
- qp->cb_data = data;
- qp->rx_handler = handlers->rx_handler;
- qp->tx_handler = handlers->tx_handler;
- qp->event_handler = handlers->event_handler;
-
- for (i = 0; i < NTB_QP_DEF_NUM_ENTRIES; i++) {
- entry = malloc(sizeof(*entry), M_NTB_IF, M_WAITOK | M_ZERO);
- entry->cb_data = nt->ifp;
- entry->buf = NULL;
- entry->len = transport_mtu;
- ntb_list_add(&qp->ntb_rx_q_lock, entry, &qp->rx_pend_q);
- }
-
- for (i = 0; i < NTB_QP_DEF_NUM_ENTRIES; i++) {
- entry = malloc(sizeof(*entry), M_NTB_IF, M_WAITOK | M_ZERO);
- ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q);
- }
-
- ntb_db_clear(ntb, 1ull << qp->qp_num);
- ntb_db_clear_mask(ntb, 1ull << qp->qp_num);
- return (qp);
-}
-
-/**
- * ntb_transport_link_up - Notify NTB transport of client readiness to use queue
- * @qp: NTB transport layer queue to be enabled
- *
- * Notify NTB transport layer of client readiness to use queue
- */
-static void
-ntb_transport_link_up(struct ntb_transport_qp *qp)
-{
- struct ntb_transport_ctx *nt;
-
- if (qp == NULL)
- return;
-
- qp->client_ready = true;
-
- nt = qp->transport;
- ntb_printf(2, "qp client ready\n");
-
- if (qp->transport->link_is_up)
- callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp);
-}
-
-
-
-/* Transport Tx */
-
-/**
- * ntb_transport_tx_enqueue - Enqueue a new NTB queue entry
- * @qp: NTB transport layer queue the entry is to be enqueued on
- * @cb: per buffer pointer for callback function to use
- * @data: pointer to data buffer that will be sent
- * @len: length of the data buffer
- *
- * Enqueue a new transmit buffer onto the transport queue from which a NTB
- * payload will be transmitted. This assumes that a lock is being held to
- * serialize access to the qp.
- *
- * RETURNS: An appropriate ERRNO error value on error, or zero for success.
- */
-static int
-ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
- unsigned int len)
-{
- struct ntb_queue_entry *entry;
- int rc;
-
- if (qp == NULL || !qp->link_is_up || len == 0) {
- CTR0(KTR_NTB, "TX: link not up");
- return (EINVAL);
- }
-
- entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q);
- if (entry == NULL) {
- CTR0(KTR_NTB, "TX: could not get entry from tx_free_q");
- qp->tx_err_no_buf++;
- return (EBUSY);
- }
- CTR1(KTR_NTB, "TX: got entry %p from tx_free_q", entry);
-
- entry->cb_data = cb;
- entry->buf = data;
- entry->len = len;
- entry->flags = 0;
-
- rc = ntb_process_tx(qp, entry);
- if (rc != 0) {
- ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q);
- CTR1(KTR_NTB,
- "TX: process_tx failed. Returning entry %p to tx_free_q",
- entry);
- }
- return (rc);
-}
-
-static int
-ntb_process_tx(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry)
-{
- void *offset;
-
- offset = qp->tx_mw + qp->tx_max_frame * qp->tx_index;
- CTR3(KTR_NTB,
- "TX: process_tx: tx_pkts=%lu, tx_index=%u, remote entry=%u",
- qp->tx_pkts, qp->tx_index, qp->remote_rx_info->entry);
- if (qp->tx_index == qp->remote_rx_info->entry) {
- CTR0(KTR_NTB, "TX: ring full");
- qp->tx_ring_full++;
- return (EAGAIN);
- }
-
- if (entry->len > qp->tx_max_frame - sizeof(struct ntb_payload_header)) {
- if (qp->tx_handler != NULL)
- qp->tx_handler(qp, qp->cb_data, entry->buf,
- EIO);
- else
- m_freem(entry->buf);
-
- entry->buf = NULL;
- ntb_list_add(&qp->ntb_tx_free_q_lock, entry, &qp->tx_free_q);
- CTR1(KTR_NTB,
- "TX: frame too big. returning entry %p to tx_free_q",
- entry);
- return (0);
- }
- CTR2(KTR_NTB, "TX: copying entry %p to offset %p", entry, offset);
- ntb_memcpy_tx(qp, entry, offset);
-
- qp->tx_index++;
- qp->tx_index %= qp->tx_max_entry;
-
- qp->tx_pkts++;
-
- return (0);
-}
-
-static void
-ntb_memcpy_tx(struct ntb_transport_qp *qp, struct ntb_queue_entry *entry,
- void *offset)
-{
- struct ntb_payload_header *hdr;
-
- /* This piece is from Linux' ntb_async_tx() */
- hdr = (struct ntb_payload_header *)((char *)offset + qp->tx_max_frame -
- sizeof(struct ntb_payload_header));
- entry->x_hdr = hdr;
- iowrite32(entry->len, &hdr->len);
- iowrite32(qp->tx_pkts, &hdr->ver);
-
- /* This piece is ntb_memcpy_tx() */
- CTR2(KTR_NTB, "TX: copying %d bytes to offset %p", entry->len, offset);
- if (entry->buf != NULL) {
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-src-head
mailing list