mirror of
https://github.com/opnsense/src.git
synced 2026-06-08 08:12:27 -04:00
a18e999454
Tcp perfomance tests show high number of retries under heave tx
traffic. The numbers of queue stops and wakeups also increase.
Further analysis suggests the FreeBSD network stack tends to send
TSO packets with multiple sg entries, typically ranging from
10 to 16. On mana, every two sgs takes one unit of tx ring.
Therefore, adding up one unit for the head, it takes 6 to 9 units
of tx ring to send a typical TSO packet.
Current default tx ring size is 256, which can get filled up
quickly under heavy load. When tx ring is full, the send queue
is stopped waiting for the ring space to be freed. This could
cause the network stack to drop packets, and lead to tcp
retransmissions.
Increase the default tx and rx ring size to 1024 units. Also
introduce two tuneables allowing users to request tx and rx ring
size in loader.conf:
hw.mana.rx_req_size
hw.mana.tx_req_size
When mana is loading, the driver checks these two values and
round them up to power of 2. If these two are not set or
the request values are out of the allowable range, it sets the
default ring size instead.
Also change the tx and rx single loop completion budget to 8.
Tested by: whu
MFC after: 2 weeks
Sponsored by: Microsoft
374 lines
12 KiB
C
374 lines
12 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*
|
|
* Copyright (c) 2021 Microsoft Corp.
|
|
* 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.
|
|
*
|
|
* 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>
|
|
#include "mana_sysctl.h"
|
|
|
|
static int mana_sysctl_cleanup_thread_cpu(SYSCTL_HANDLER_ARGS);
|
|
|
|
int mana_log_level = MANA_ALERT | MANA_WARNING | MANA_INFO;
|
|
|
|
unsigned int mana_tx_req_size;
|
|
unsigned int mana_rx_req_size;
|
|
|
|
SYSCTL_NODE(_hw, OID_AUTO, mana, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
|
|
"MANA driver parameters");
|
|
|
|
SYSCTL_UINT(_hw_mana, OID_AUTO, tx_req_size, CTLFLAG_RWTUN,
|
|
&mana_tx_req_size, 0, "requested number of unit of tx queue");
|
|
SYSCTL_UINT(_hw_mana, OID_AUTO, rx_req_size, CTLFLAG_RWTUN,
|
|
&mana_rx_req_size, 0, "requested number of unit of rx queue");
|
|
|
|
/*
|
|
* Logging level for changing verbosity of the output
|
|
*/
|
|
SYSCTL_INT(_hw_mana, OID_AUTO, log_level, CTLFLAG_RWTUN,
|
|
&mana_log_level, 0, "Logging level indicating verbosity of the logs");
|
|
|
|
SYSCTL_CONST_STRING(_hw_mana, OID_AUTO, driver_version, CTLFLAG_RD,
|
|
DRV_MODULE_VERSION, "MANA driver version");
|
|
|
|
static int
|
|
mana_sysctl_rx_stat_agg_u64(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct mana_port_context *apc = arg1;
|
|
int offset = arg2, i, err;
|
|
struct mana_rxq *rxq;
|
|
uint64_t stat;
|
|
|
|
stat = 0;
|
|
for (i = 0; i < apc->num_queues; i++) {
|
|
rxq = apc->rxqs[i];
|
|
stat += *((uint64_t *)((uint8_t *)rxq + offset));
|
|
}
|
|
|
|
err = sysctl_handle_64(oidp, &stat, 0, req);
|
|
if (err || req->newptr == NULL)
|
|
return err;
|
|
|
|
for (i = 0; i < apc->num_queues; i++) {
|
|
rxq = apc->rxqs[i];
|
|
*((uint64_t *)((uint8_t *)rxq + offset)) = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mana_sysctl_rx_stat_u16(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct mana_port_context *apc = arg1;
|
|
int offset = arg2, err;
|
|
struct mana_rxq *rxq;
|
|
uint64_t stat;
|
|
uint16_t val;
|
|
|
|
rxq = apc->rxqs[0];
|
|
val = *((uint16_t *)((uint8_t *)rxq + offset));
|
|
stat = val;
|
|
|
|
err = sysctl_handle_64(oidp, &stat, 0, req);
|
|
if (err || req->newptr == NULL)
|
|
return err;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mana_sysctl_rx_stat_u32(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct mana_port_context *apc = arg1;
|
|
int offset = arg2, err;
|
|
struct mana_rxq *rxq;
|
|
uint64_t stat;
|
|
uint32_t val;
|
|
|
|
rxq = apc->rxqs[0];
|
|
val = *((uint32_t *)((uint8_t *)rxq + offset));
|
|
stat = val;
|
|
|
|
err = sysctl_handle_64(oidp, &stat, 0, req);
|
|
if (err || req->newptr == NULL)
|
|
return err;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mana_sysctl_tx_stat_agg_u64(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct mana_port_context *apc = arg1;
|
|
int offset = arg2, i, err;
|
|
struct mana_txq *txq;
|
|
uint64_t stat;
|
|
|
|
stat = 0;
|
|
for (i = 0; i < apc->num_queues; i++) {
|
|
txq = &apc->tx_qp[i].txq;
|
|
stat += *((uint64_t *)((uint8_t *)txq + offset));
|
|
}
|
|
|
|
err = sysctl_handle_64(oidp, &stat, 0, req);
|
|
if (err || req->newptr == NULL)
|
|
return err;
|
|
|
|
for (i = 0; i < apc->num_queues; i++) {
|
|
txq = &apc->tx_qp[i].txq;
|
|
*((uint64_t *)((uint8_t *)txq + offset)) = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
mana_sysctl_add_port(struct mana_port_context *apc)
|
|
{
|
|
struct gdma_context *gc = apc->ac->gdma_dev->gdma_context;
|
|
device_t dev = gc->dev;
|
|
struct sysctl_ctx_list *ctx;
|
|
struct sysctl_oid *tree;
|
|
struct sysctl_oid_list *child;
|
|
struct mana_port_stats *port_stats;
|
|
char node_name[32];
|
|
|
|
struct sysctl_oid *port_node, *stats_node;
|
|
struct sysctl_oid_list *stats_list;
|
|
|
|
ctx = device_get_sysctl_ctx(dev);
|
|
tree = device_get_sysctl_tree(dev);
|
|
child = SYSCTL_CHILDREN(tree);
|
|
|
|
port_stats = &apc->port_stats;
|
|
|
|
snprintf(node_name, 32, "port%d", apc->port_idx);
|
|
|
|
port_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO,
|
|
node_name, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Port Name");
|
|
apc->port_list = SYSCTL_CHILDREN(port_node);
|
|
|
|
SYSCTL_ADD_BOOL(ctx, apc->port_list, OID_AUTO,
|
|
"enable_altq", CTLFLAG_RW, &apc->enable_tx_altq, 0,
|
|
"Choose alternative txq under heavy load");
|
|
|
|
SYSCTL_ADD_UINT(ctx, apc->port_list, OID_AUTO,
|
|
"tx_queue_size", CTLFLAG_RD, &apc->tx_queue_size, 0,
|
|
"number of unit of tx queue");
|
|
|
|
SYSCTL_ADD_UINT(ctx, apc->port_list, OID_AUTO,
|
|
"rx_queue_size", CTLFLAG_RD, &apc->rx_queue_size, 0,
|
|
"number of unit of rx queue");
|
|
|
|
SYSCTL_ADD_PROC(ctx, apc->port_list, OID_AUTO,
|
|
"bind_cleanup_thread_cpu",
|
|
CTLTYPE_U8 | CTLFLAG_RW | CTLFLAG_MPSAFE,
|
|
apc, 0, mana_sysctl_cleanup_thread_cpu, "I",
|
|
"Bind cleanup thread to a cpu. 0 disables it.");
|
|
|
|
stats_node = SYSCTL_ADD_NODE(ctx, apc->port_list, OID_AUTO,
|
|
"port_stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
|
|
"Statistics of port");
|
|
stats_list = SYSCTL_CHILDREN(stats_node);
|
|
|
|
SYSCTL_ADD_COUNTER_U64(ctx, stats_list, OID_AUTO, "rx_packets",
|
|
CTLFLAG_RD, &port_stats->rx_packets, "Packets received");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, stats_list, OID_AUTO, "tx_packets",
|
|
CTLFLAG_RD, &port_stats->tx_packets, "Packets transmitted");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, stats_list, OID_AUTO, "rx_bytes",
|
|
CTLFLAG_RD, &port_stats->rx_bytes, "Bytes received");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, stats_list, OID_AUTO, "tx_bytes",
|
|
CTLFLAG_RD, &port_stats->tx_bytes, "Bytes transmitted");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, stats_list, OID_AUTO, "rx_drops",
|
|
CTLFLAG_RD, &port_stats->rx_drops, "Receive packet drops");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, stats_list, OID_AUTO, "tx_drops",
|
|
CTLFLAG_RD, &port_stats->tx_drops, "Transmit packet drops");
|
|
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "rx_lro_queued",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro.lro_queued),
|
|
mana_sysctl_rx_stat_agg_u64, "LU", "LRO queued");
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "rx_lro_flushed",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro.lro_flushed),
|
|
mana_sysctl_rx_stat_agg_u64, "LU", "LRO flushed");
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "rx_lro_bad_csum",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro.lro_bad_csum),
|
|
mana_sysctl_rx_stat_agg_u64, "LU", "LRO bad checksum");
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "rx_lro_tried",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro_tried),
|
|
mana_sysctl_rx_stat_agg_u64, "LU", "LRO tried");
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "rx_lro_failed",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro_failed),
|
|
mana_sysctl_rx_stat_agg_u64, "LU", "LRO failed");
|
|
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "lro_ackcnt_lim",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro.lro_ackcnt_lim),
|
|
mana_sysctl_rx_stat_u16,
|
|
"LU", "Max # of ACKs to be aggregated by LRO");
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "lro_length_lim",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro.lro_length_lim),
|
|
mana_sysctl_rx_stat_u32,
|
|
"LU", "Max len of aggregated data in byte by LRO");
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "lro_cnt",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_rxq, lro.lro_cnt),
|
|
mana_sysctl_rx_stat_u32,
|
|
"LU", "Max # or LRO packet count");
|
|
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "tx_tso_packets",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_txq, tso_pkts),
|
|
mana_sysctl_tx_stat_agg_u64, "LU", "TSO packets");
|
|
SYSCTL_ADD_PROC(ctx, stats_list, OID_AUTO, "tx_tso_bytes",
|
|
CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, apc,
|
|
__offsetof(struct mana_txq, tso_bytes),
|
|
mana_sysctl_tx_stat_agg_u64, "LU", "TSO bytes");
|
|
}
|
|
|
|
void
|
|
mana_sysctl_add_queues(struct mana_port_context *apc)
|
|
{
|
|
struct sysctl_ctx_list *ctx = &apc->que_sysctl_ctx;
|
|
struct sysctl_oid_list *child = apc->port_list;
|
|
|
|
struct sysctl_oid *queue_node, *tx_node, *rx_node;
|
|
struct sysctl_oid_list *queue_list, *tx_list, *rx_list;
|
|
struct mana_txq *txq;
|
|
struct mana_rxq *rxq;
|
|
struct mana_stats *tx_stats, *rx_stats;
|
|
char que_name[32];
|
|
int i;
|
|
|
|
sysctl_ctx_init(ctx);
|
|
|
|
for (i = 0; i < apc->num_queues; i++) {
|
|
rxq = apc->rxqs[i];
|
|
txq = &apc->tx_qp[i].txq;
|
|
|
|
snprintf(que_name, 32, "queue%d", i);
|
|
|
|
queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO,
|
|
que_name, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
|
|
queue_list = SYSCTL_CHILDREN(queue_node);
|
|
|
|
/* TX stats */
|
|
tx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO,
|
|
"txq", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX queue");
|
|
tx_list = SYSCTL_CHILDREN(tx_node);
|
|
|
|
tx_stats = &txq->stats;
|
|
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "count",
|
|
CTLFLAG_RD, &tx_stats->packets, "Packets sent");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "bytes",
|
|
CTLFLAG_RD, &tx_stats->bytes, "Bytes sent");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "queue_wakeups",
|
|
CTLFLAG_RD, &tx_stats->wakeup, "Queue wakeups");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "queue_stops",
|
|
CTLFLAG_RD, &tx_stats->stop, "Queue stops");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "mbuf_collapse",
|
|
CTLFLAG_RD, &tx_stats->collapse, "Mbuf collapse count");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO,
|
|
"mbuf_collapse_err", CTLFLAG_RD,
|
|
&tx_stats->collapse_err, "Mbuf collapse failures");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO,
|
|
"dma_mapping_err", CTLFLAG_RD,
|
|
&tx_stats->dma_mapping_err, "DMA mapping failures");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO,
|
|
"alt_chg", CTLFLAG_RD,
|
|
&tx_stats->alt_chg, "Switch to alternative txq");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO,
|
|
"alt_reset", CTLFLAG_RD,
|
|
&tx_stats->alt_reset, "Reset to self txq");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO,
|
|
"cqe_err", CTLFLAG_RD,
|
|
&tx_stats->cqe_err, "Error CQE count");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO,
|
|
"cqe_unknown_type", CTLFLAG_RD,
|
|
&tx_stats->cqe_unknown_type, "Unknown CQE count");
|
|
|
|
/* RX stats */
|
|
rx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO,
|
|
"rxq", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX queue");
|
|
rx_list = SYSCTL_CHILDREN(rx_node);
|
|
|
|
rx_stats = &rxq->stats;
|
|
|
|
SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "count",
|
|
CTLFLAG_RD, &rx_stats->packets, "Packets received");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "bytes",
|
|
CTLFLAG_RD, &rx_stats->bytes, "Bytes received");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO,
|
|
"mbuf_alloc_fail", CTLFLAG_RD,
|
|
&rx_stats->mbuf_alloc_fail, "Failed mbuf allocs");
|
|
SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO,
|
|
"dma_mapping_err", CTLFLAG_RD,
|
|
&rx_stats->dma_mapping_err, "DMA mapping errors");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Free all queues' sysctl trees attached to the port's tree.
|
|
*/
|
|
void
|
|
mana_sysctl_free_queues(struct mana_port_context *apc)
|
|
{
|
|
sysctl_ctx_free(&apc->que_sysctl_ctx);
|
|
}
|
|
|
|
static int
|
|
mana_sysctl_cleanup_thread_cpu(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct mana_port_context *apc = arg1;
|
|
bool bind_cpu = false;
|
|
uint8_t val;
|
|
int err;
|
|
|
|
val = 0;
|
|
err = sysctl_wire_old_buffer(req, sizeof(val));
|
|
if (err == 0) {
|
|
val = apc->bind_cleanup_thread_cpu;
|
|
err = sysctl_handle_8(oidp, &val, 0, req);
|
|
}
|
|
|
|
if (err != 0 || req->newptr == NULL)
|
|
return (err);
|
|
|
|
if (val != 0)
|
|
bind_cpu = true;
|
|
|
|
if (bind_cpu != apc->bind_cleanup_thread_cpu) {
|
|
apc->bind_cleanup_thread_cpu = bind_cpu;
|
|
err = mana_restart(apc);
|
|
}
|
|
|
|
return (err);
|
|
}
|