Changeset View
Changeset View
Standalone View
Standalone View
sys/dev/cxgbe/t4_main.c
Show All 12 Lines | |||||
* | * | ||||
* Each tunable is set to a default value here if it's known at compile-time. | * Each tunable is set to a default value here if it's known at compile-time. | ||||
* Otherwise it is set to -n as an indication to tweak_tunables() that it should | * Otherwise it is set to -n as an indication to tweak_tunables() that it should | ||||
* provide a reasonable default (upto n) when the driver is loaded. | * provide a reasonable default (upto n) when the driver is loaded. | ||||
* | * | ||||
* Tunables applicable to both T4 and T5 are under hw.cxgbe. Those specific to | * Tunables applicable to both T4 and T5 are under hw.cxgbe. Those specific to | ||||
* T5 are under hw.cxl. | * T5 are under hw.cxl. | ||||
*/ | */ | ||||
SYSCTL_NODE(_hw, OID_AUTO, cxgbe, CTLFLAG_RD, 0, "cxgbe(4) parameters"); | SYSCTL_NODE(_hw, OID_AUTO, cxgbe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, | ||||
SYSCTL_NODE(_hw, OID_AUTO, cxl, CTLFLAG_RD, 0, "cxgbe(4) T5+ parameters"); | "cxgbe(4) parameters"); | ||||
SYSCTL_NODE(_hw_cxgbe, OID_AUTO, toe, CTLFLAG_RD, 0, "cxgbe(4) TOE parameters"); | SYSCTL_NODE(_hw, OID_AUTO, cxl, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, | ||||
"cxgbe(4) T5+ parameters"); | |||||
SYSCTL_NODE(_hw_cxgbe, OID_AUTO, toe, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, | |||||
"cxgbe(4) TOE parameters"); | |||||
/* | /* | ||||
* Number of queues for tx and rx, NIC and offload. | * Number of queues for tx and rx, NIC and offload. | ||||
*/ | */ | ||||
#define NTXQ 16 | #define NTXQ 16 | ||||
int t4_ntxq = -NTXQ; | int t4_ntxq = -NTXQ; | ||||
SYSCTL_INT(_hw_cxgbe, OID_AUTO, ntxq, CTLFLAG_RDTUN, &t4_ntxq, 0, | SYSCTL_INT(_hw_cxgbe, OID_AUTO, ntxq, CTLFLAG_RDTUN, &t4_ntxq, 0, | ||||
"Number of TX queues per port"); | "Number of TX queues per port"); | ||||
Show All 24 Lines | |||||
static int t4_toe_rexmt_count = 0; | static int t4_toe_rexmt_count = 0; | ||||
SYSCTL_INT(_hw_cxgbe_toe, OID_AUTO, rexmt_count, CTLFLAG_RDTUN, | SYSCTL_INT(_hw_cxgbe_toe, OID_AUTO, rexmt_count, CTLFLAG_RDTUN, | ||||
&t4_toe_rexmt_count, 0, "Number of TOE retransmissions before abort"); | &t4_toe_rexmt_count, 0, "Number of TOE retransmissions before abort"); | ||||
/* -1 means chip/fw default, other values are raw backoff values to use */ | /* -1 means chip/fw default, other values are raw backoff values to use */ | ||||
static int t4_toe_rexmt_backoff[16] = { | static int t4_toe_rexmt_backoff[16] = { | ||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 | ||||
}; | }; | ||||
SYSCTL_NODE(_hw_cxgbe_toe, OID_AUTO, rexmt_backoff, CTLFLAG_RD, 0, | SYSCTL_NODE(_hw_cxgbe_toe, OID_AUTO, rexmt_backoff, | ||||
CTLFLAG_RD | CTLFLAG_MPSAFE, 0, | |||||
"cxgbe(4) TOE retransmit backoff values"); | "cxgbe(4) TOE retransmit backoff values"); | ||||
SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 0, CTLFLAG_RDTUN, | SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 0, CTLFLAG_RDTUN, | ||||
&t4_toe_rexmt_backoff[0], 0, ""); | &t4_toe_rexmt_backoff[0], 0, ""); | ||||
SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 1, CTLFLAG_RDTUN, | SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 1, CTLFLAG_RDTUN, | ||||
&t4_toe_rexmt_backoff[1], 0, ""); | &t4_toe_rexmt_backoff[1], 0, ""); | ||||
SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 2, CTLFLAG_RDTUN, | SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 2, CTLFLAG_RDTUN, | ||||
&t4_toe_rexmt_backoff[2], 0, ""); | &t4_toe_rexmt_backoff[2], 0, ""); | ||||
SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 3, CTLFLAG_RDTUN, | SYSCTL_INT(_hw_cxgbe_toe_rexmt_backoff, OID_AUTO, 3, CTLFLAG_RDTUN, | ||||
Show All 24 Lines | |||||
#ifdef KERN_TLS | #ifdef KERN_TLS | ||||
/* | /* | ||||
* This enables KERN_TLS for all adapters if set. | * This enables KERN_TLS for all adapters if set. | ||||
*/ | */ | ||||
static int t4_kern_tls = 0; | static int t4_kern_tls = 0; | ||||
SYSCTL_INT(_hw_cxgbe, OID_AUTO, kern_tls, CTLFLAG_RDTUN, &t4_kern_tls, 0, | SYSCTL_INT(_hw_cxgbe, OID_AUTO, kern_tls, CTLFLAG_RDTUN, &t4_kern_tls, 0, | ||||
"Enable KERN_TLS mode for all supported adapters"); | "Enable KERN_TLS mode for all supported adapters"); | ||||
SYSCTL_NODE(_hw_cxgbe, OID_AUTO, tls, CTLFLAG_RD, 0, | SYSCTL_NODE(_hw_cxgbe, OID_AUTO, tls, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, | ||||
"cxgbe(4) KERN_TLS parameters"); | "cxgbe(4) KERN_TLS parameters"); | ||||
static int t4_tls_inline_keys = 0; | static int t4_tls_inline_keys = 0; | ||||
SYSCTL_INT(_hw_cxgbe_tls, OID_AUTO, inline_keys, CTLFLAG_RDTUN, | SYSCTL_INT(_hw_cxgbe_tls, OID_AUTO, inline_keys, CTLFLAG_RDTUN, | ||||
&t4_tls_inline_keys, 0, | &t4_tls_inline_keys, 0, | ||||
"Always pass TLS keys in work requests (1) or attempt to store TLS keys " | "Always pass TLS keys in work requests (1) or attempt to store TLS keys " | ||||
"in card memory."); | "in card memory."); | ||||
Show All 24 Lines | |||||
sc->sc_do_rxcopy = 1; | sc->sc_do_rxcopy = 1; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "do_rx_copy", CTLFLAG_RW, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "do_rx_copy", CTLFLAG_RW, | ||||
&sc->sc_do_rxcopy, 1, "Do RX copy of small frames"); | &sc->sc_do_rxcopy, 1, "Do RX copy of small frames"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nports", CTLFLAG_RD, NULL, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nports", CTLFLAG_RD, NULL, | ||||
sc->params.nports, "# of ports"); | sc->params.nports, "# of ports"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "doorbells", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "doorbells", | ||||
CTLTYPE_STRING | CTLFLAG_RD, doorbells, (uintptr_t)&sc->doorbells, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, doorbells, | ||||
sysctl_bitfield_8b, "A", "available doorbells"); | (uintptr_t)&sc->doorbells, sysctl_bitfield_8b, "A", | ||||
"available doorbells"); | |||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "core_clock", CTLFLAG_RD, NULL, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "core_clock", CTLFLAG_RD, NULL, | ||||
sc->params.vpd.cclk, "core clock frequency (in KHz)"); | sc->params.vpd.cclk, "core clock frequency (in KHz)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_timers", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_timers", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc->params.sge.timer_val, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, | ||||
sizeof(sc->params.sge.timer_val), sysctl_int_array, "A", | sc->params.sge.timer_val, sizeof(sc->params.sge.timer_val), | ||||
"interrupt holdoff timer values (us)"); | sysctl_int_array, "A", "interrupt holdoff timer values (us)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pkt_counts", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pkt_counts", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc->params.sge.counter_val, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, | ||||
sizeof(sc->params.sge.counter_val), sysctl_int_array, "A", | sc->params.sge.counter_val, sizeof(sc->params.sge.counter_val), | ||||
"interrupt holdoff packet counter values"); | sysctl_int_array, "A", "interrupt holdoff packet counter values"); | ||||
t4_sge_sysctls(sc, ctx, children); | t4_sge_sysctls(sc, ctx, children); | ||||
sc->lro_timeout = 100; | sc->lro_timeout = 100; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "lro_timeout", CTLFLAG_RW, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "lro_timeout", CTLFLAG_RW, | ||||
&sc->lro_timeout, 0, "lro inactive-flush timeout (in us)"); | &sc->lro_timeout, 0, "lro inactive-flush timeout (in us)"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "dflags", CTLFLAG_RW, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "dflags", CTLFLAG_RW, | ||||
Show All 24 Lines | |||||
SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "cf", | SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "cf", | ||||
CTLFLAG_RD, sc->cfg_file, 0, "configuration file"); | CTLFLAG_RD, sc->cfg_file, 0, "configuration file"); | ||||
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cfcsum", CTLFLAG_RD, NULL, | SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cfcsum", CTLFLAG_RD, NULL, | ||||
sc->cfcsum, "config file checksum"); | sc->cfcsum, "config file checksum"); | ||||
#define SYSCTL_CAP(name, n, text) \ | #define SYSCTL_CAP(name, n, text) \ | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, #name, \ | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, #name, \ | ||||
CTLTYPE_STRING | CTLFLAG_RD, caps_decoder[n], (uintptr_t)&sc->name, \ | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, caps_decoder[n], \ | ||||
sysctl_bitfield_16b, "A", "available " text " capabilities") | (uintptr_t)&sc->name, sysctl_bitfield_16b, "A", \ | ||||
"available " text " capabilities") | |||||
SYSCTL_CAP(nbmcaps, 0, "NBM"); | SYSCTL_CAP(nbmcaps, 0, "NBM"); | ||||
SYSCTL_CAP(linkcaps, 1, "link"); | SYSCTL_CAP(linkcaps, 1, "link"); | ||||
SYSCTL_CAP(switchcaps, 2, "switch"); | SYSCTL_CAP(switchcaps, 2, "switch"); | ||||
SYSCTL_CAP(niccaps, 3, "NIC"); | SYSCTL_CAP(niccaps, 3, "NIC"); | ||||
SYSCTL_CAP(toecaps, 4, "TCP offload"); | SYSCTL_CAP(toecaps, 4, "TCP offload"); | ||||
SYSCTL_CAP(rdmacaps, 5, "RDMA"); | SYSCTL_CAP(rdmacaps, 5, "RDMA"); | ||||
SYSCTL_CAP(iscsicaps, 6, "iSCSI"); | SYSCTL_CAP(iscsicaps, 6, "iSCSI"); | ||||
SYSCTL_CAP(cryptocaps, 7, "crypto"); | SYSCTL_CAP(cryptocaps, 7, "crypto"); | ||||
SYSCTL_CAP(fcoecaps, 8, "FCoE"); | SYSCTL_CAP(fcoecaps, 8, "FCoE"); | ||||
#undef SYSCTL_CAP | #undef SYSCTL_CAP | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nfilters", CTLFLAG_RD, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nfilters", CTLFLAG_RD, | ||||
NULL, sc->tids.nftids, "number of filters"); | NULL, sc->tids.nftids, "number of filters"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature", CTLTYPE_INT | | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature", | ||||
CTLFLAG_RD, sc, 0, sysctl_temperature, "I", | CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
"chip temperature (in Celsius)"); | sysctl_temperature, "I", "chip temperature (in Celsius)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "reset_sensor", CTLTYPE_INT | | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "reset_sensor", | ||||
CTLFLAG_RW, sc, 0, sysctl_reset_sensor, "I", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0, | ||||
"reset the chip's temperature sensor."); | sysctl_reset_sensor, "I", "reset the chip's temperature sensor."); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "loadavg", CTLTYPE_STRING | | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "loadavg", | ||||
CTLFLAG_RD, sc, 0, sysctl_loadavg, "A", | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_loadavg, "A", | |||||
"microprocessor load averages (debug firmwares only)"); | "microprocessor load averages (debug firmwares only)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "core_vdd", CTLTYPE_INT | | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "core_vdd", | ||||
CTLFLAG_RD, sc, 0, sysctl_vdd, "I", "core Vdd (in mV)"); | CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, sysctl_vdd, | ||||
"I", "core Vdd (in mV)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "local_cpus", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "local_cpus", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, LOCAL_CPUS, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, LOCAL_CPUS, | ||||
sysctl_cpus, "A", "local CPUs"); | sysctl_cpus, "A", "local CPUs"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_cpus", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "intr_cpus", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, INTR_CPUS, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, INTR_CPUS, | ||||
sysctl_cpus, "A", "preferred CPUs for interrupts"); | sysctl_cpus, "A", "preferred CPUs for interrupts"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "swintr", CTLFLAG_RW, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "swintr", CTLFLAG_RW, | ||||
&sc->swintr, 0, "software triggered interrupts"); | &sc->swintr, 0, "software triggered interrupts"); | ||||
/* | /* | ||||
* dev.t4nex.X.misc. Marked CTLFLAG_SKIP to avoid information overload. | * dev.t4nex.X.misc. Marked CTLFLAG_SKIP to avoid information overload. | ||||
*/ | */ | ||||
oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "misc", | oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "misc", | ||||
CTLFLAG_RD | CTLFLAG_SKIP, NULL, | CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_MPSAFE, NULL, | ||||
"logs and miscellaneous information"); | "logs and miscellaneous information"); | ||||
children = SYSCTL_CHILDREN(oid); | children = SYSCTL_CHILDREN(oid); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cctrl", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cctrl", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_cctrl, "A", "congestion control"); | sysctl_cctrl, "A", "congestion control"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp0", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp0", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_cim_ibq_obq, "A", "CIM IBQ 0 (TP0)"); | sysctl_cim_ibq_obq, "A", "CIM IBQ 0 (TP0)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp1", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp1", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 1, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 1, | ||||
sysctl_cim_ibq_obq, "A", "CIM IBQ 1 (TP1)"); | sysctl_cim_ibq_obq, "A", "CIM IBQ 1 (TP1)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ulp", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ulp", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 2, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 2, | ||||
sysctl_cim_ibq_obq, "A", "CIM IBQ 2 (ULP)"); | sysctl_cim_ibq_obq, "A", "CIM IBQ 2 (ULP)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge0", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge0", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 3, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 3, | ||||
sysctl_cim_ibq_obq, "A", "CIM IBQ 3 (SGE0)"); | sysctl_cim_ibq_obq, "A", "CIM IBQ 3 (SGE0)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge1", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge1", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 4, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 4, | ||||
sysctl_cim_ibq_obq, "A", "CIM IBQ 4 (SGE1)"); | sysctl_cim_ibq_obq, "A", "CIM IBQ 4 (SGE1)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ncsi", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ncsi", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 5, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 5, | ||||
sysctl_cim_ibq_obq, "A", "CIM IBQ 5 (NCSI)"); | sysctl_cim_ibq_obq, "A", "CIM IBQ 5 (NCSI)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_la", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_la", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, sysctl_cim_la, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
"A", "CIM logic analyzer"); | sysctl_cim_la, "A", "CIM logic analyzer"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ma_la", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ma_la", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_cim_ma_la, "A", "CIM MA logic analyzer"); | sysctl_cim_ma_la, "A", "CIM MA logic analyzer"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp0", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp0", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 0 (ULP0)"); | 0 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 0 (ULP0)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp1", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp1", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 1 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 1 (ULP1)"); | 1 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 1 (ULP1)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp2", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp2", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 2 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 2 (ULP2)"); | 2 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 2 (ULP2)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp3", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp3", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 3 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 3 (ULP3)"); | 3 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 3 (ULP3)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 4 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 4 (SGE)"); | 4 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 4 (SGE)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ncsi", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ncsi", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 5 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 5 (NCSI)"); | 5 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", "CIM OBQ 5 (NCSI)"); | ||||
if (chip_id(sc) > CHELSIO_T4) { | if (chip_id(sc) > CHELSIO_T4) { | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge0_rx", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge0_rx", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 6 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 6 (SGE0-RX)"); | 6 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", | ||||
"CIM OBQ 6 (SGE0-RX)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge1_rx", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge1_rx", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 7 + CIM_NUM_IBQ, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_cim_ibq_obq, "A", "CIM OBQ 7 (SGE1-RX)"); | 7 + CIM_NUM_IBQ, sysctl_cim_ibq_obq, "A", | ||||
"CIM OBQ 7 (SGE1-RX)"); | |||||
} | } | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_pif_la", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_pif_la", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_cim_pif_la, "A", "CIM PIF logic analyzer"); | sysctl_cim_pif_la, "A", "CIM PIF logic analyzer"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_qcfg", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_qcfg", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_cim_qcfg, "A", "CIM queue configuration"); | sysctl_cim_qcfg, "A", "CIM queue configuration"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cpl_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cpl_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_cpl_stats, "A", "CPL statistics"); | sysctl_cpl_stats, "A", "CPL statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ddp_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ddp_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_ddp_stats, "A", "non-TCP DDP statistics"); | sysctl_ddp_stats, "A", "non-TCP DDP statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "devlog", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "devlog", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_devlog, "A", "firmware's device log"); | sysctl_devlog, "A", "firmware's device log"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fcoe_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fcoe_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_fcoe_stats, "A", "FCoE statistics"); | sysctl_fcoe_stats, "A", "FCoE statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "hw_sched", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "hw_sched", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_hw_sched, "A", "hardware scheduler "); | sysctl_hw_sched, "A", "hardware scheduler "); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "l2t", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "l2t", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_l2t, "A", "hardware L2 table"); | sysctl_l2t, "A", "hardware L2 table"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "smt", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "smt", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_smt, "A", "hardware source MAC table"); | sysctl_smt, "A", "hardware source MAC table"); | ||||
#ifdef INET6 | #ifdef INET6 | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "clip", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "clip", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_clip, "A", "active CLIP table entries"); | sysctl_clip, "A", "active CLIP table entries"); | ||||
#endif | #endif | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "lb_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "lb_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_lb_stats, "A", "loopback statistics"); | sysctl_lb_stats, "A", "loopback statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "meminfo", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "meminfo", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_meminfo, "A", "memory regions"); | sysctl_meminfo, "A", "memory regions"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "mps_tcam", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "mps_tcam", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
chip_id(sc) <= CHELSIO_T5 ? sysctl_mps_tcam : sysctl_mps_tcam_t6, | chip_id(sc) <= CHELSIO_T5 ? sysctl_mps_tcam : sysctl_mps_tcam_t6, | ||||
"A", "MPS TCAM entries"); | "A", "MPS TCAM entries"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "path_mtus", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "path_mtus", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_path_mtus, "A", "path MTUs"); | sysctl_path_mtus, "A", "path MTUs"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pm_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pm_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_pm_stats, "A", "PM statistics"); | sysctl_pm_stats, "A", "PM statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rdma_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rdma_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_rdma_stats, "A", "RDMA statistics"); | sysctl_rdma_stats, "A", "RDMA statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tcp_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tcp_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_tcp_stats, "A", "TCP statistics"); | sysctl_tcp_stats, "A", "TCP statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tids", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tids", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_tids, "A", "TID information"); | sysctl_tids, "A", "TID information"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_err_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_err_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_tp_err_stats, "A", "TP error statistics"); | sysctl_tp_err_stats, "A", "TP error statistics"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_la_mask", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_la_mask", | ||||
CTLTYPE_INT | CTLFLAG_RW, sc, 0, sysctl_tp_la_mask, "I", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0, | ||||
"TP logic analyzer event capture mask"); | sysctl_tp_la_mask, "I", "TP logic analyzer event capture mask"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_la", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_la", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_tp_la, "A", "TP logic analyzer"); | sysctl_tp_la, "A", "TP logic analyzer"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_rate", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_rate", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_tx_rate, "A", "Tx rate"); | sysctl_tx_rate, "A", "Tx rate"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ulprx_la", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ulprx_la", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_ulprx_la, "A", "ULPRX logic analyzer"); | sysctl_ulprx_la, "A", "ULPRX logic analyzer"); | ||||
if (chip_id(sc) >= CHELSIO_T5) { | if (chip_id(sc) >= CHELSIO_T5) { | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "wcwr_stats", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "wcwr_stats", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
sysctl_wcwr_stats, "A", "write combined work requests"); | sysctl_wcwr_stats, "A", "write combined work requests"); | ||||
} | } | ||||
#ifdef KERN_TLS | #ifdef KERN_TLS | ||||
if (sc->flags & KERN_TLS_OK) { | if (sc->flags & KERN_TLS_OK) { | ||||
/* | /* | ||||
* dev.t4nex.0.tls. | * dev.t4nex.0.tls. | ||||
*/ | */ | ||||
oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "tls", CTLFLAG_RD, | oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "tls", | ||||
NULL, "KERN_TLS parameters"); | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "KERN_TLS parameters"); | ||||
children = SYSCTL_CHILDREN(oid); | children = SYSCTL_CHILDREN(oid); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "inline_keys", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "inline_keys", | ||||
CTLFLAG_RW, &sc->tlst.inline_keys, 0, "Always pass TLS " | CTLFLAG_RW, &sc->tlst.inline_keys, 0, "Always pass TLS " | ||||
"keys in work requests (1) or attempt to store TLS keys " | "keys in work requests (1) or attempt to store TLS keys " | ||||
"in card memory."); | "in card memory."); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "combo_wrs", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "combo_wrs", | ||||
CTLFLAG_RW, &sc->tlst.combo_wrs, 0, "Attempt to combine " | CTLFLAG_RW, &sc->tlst.combo_wrs, 0, "Attempt to combine " | ||||
"TCB field updates with TLS record work requests."); | "TCB field updates with TLS record work requests."); | ||||
} | } | ||||
#endif | #endif | ||||
#ifdef TCP_OFFLOAD | #ifdef TCP_OFFLOAD | ||||
if (is_offload(sc)) { | if (is_offload(sc)) { | ||||
int i; | int i; | ||||
char s[4]; | char s[4]; | ||||
/* | /* | ||||
* dev.t4nex.X.toe. | * dev.t4nex.X.toe. | ||||
*/ | */ | ||||
oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "toe", CTLFLAG_RD, | oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "toe", | ||||
NULL, "TOE parameters"); | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TOE parameters"); | ||||
children = SYSCTL_CHILDREN(oid); | children = SYSCTL_CHILDREN(oid); | ||||
sc->tt.cong_algorithm = -1; | sc->tt.cong_algorithm = -1; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "cong_algorithm", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "cong_algorithm", | ||||
CTLFLAG_RW, &sc->tt.cong_algorithm, 0, "congestion control " | CTLFLAG_RW, &sc->tt.cong_algorithm, 0, "congestion control " | ||||
"(-1 = default, 0 = reno, 1 = tahoe, 2 = newreno, " | "(-1 = default, 0 = reno, 1 = tahoe, 2 = newreno, " | ||||
"3 = highspeed)"); | "3 = highspeed)"); | ||||
Show All 11 Lines | |||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "rx_coalesce", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "rx_coalesce", | ||||
CTLFLAG_RW, &sc->tt.rx_coalesce, 0, "receive coalescing"); | CTLFLAG_RW, &sc->tt.rx_coalesce, 0, "receive coalescing"); | ||||
sc->tt.tls = 0; | sc->tt.tls = 0; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tls", CTLFLAG_RW, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tls", CTLFLAG_RW, | ||||
&sc->tt.tls, 0, "Inline TLS allowed"); | &sc->tt.tls, 0, "Inline TLS allowed"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tls_rx_ports", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tls_rx_ports", | ||||
CTLTYPE_INT | CTLFLAG_RW, sc, 0, sysctl_tls_rx_ports, | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0, | ||||
"I", "TCP ports that use inline TLS+TOE RX"); | sysctl_tls_rx_ports, "I", | ||||
"TCP ports that use inline TLS+TOE RX"); | |||||
sc->tt.tx_align = -1; | sc->tt.tx_align = -1; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tx_align", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tx_align", | ||||
CTLFLAG_RW, &sc->tt.tx_align, 0, "chop and align payload"); | CTLFLAG_RW, &sc->tt.tx_align, 0, "chop and align payload"); | ||||
sc->tt.tx_zcopy = 0; | sc->tt.tx_zcopy = 0; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tx_zcopy", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tx_zcopy", | ||||
CTLFLAG_RW, &sc->tt.tx_zcopy, 0, | CTLFLAG_RW, &sc->tt.tx_zcopy, 0, | ||||
"Enable zero-copy aio_write(2)"); | "Enable zero-copy aio_write(2)"); | ||||
sc->tt.cop_managed_offloading = !!t4_cop_managed_offloading; | sc->tt.cop_managed_offloading = !!t4_cop_managed_offloading; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, | ||||
"cop_managed_offloading", CTLFLAG_RW, | "cop_managed_offloading", CTLFLAG_RW, | ||||
&sc->tt.cop_managed_offloading, 0, | &sc->tt.cop_managed_offloading, 0, | ||||
"COP (Connection Offload Policy) controls all TOE offload"); | "COP (Connection Offload Policy) controls all TOE offload"); | ||||
sc->tt.autorcvbuf_inc = 16 * 1024; | sc->tt.autorcvbuf_inc = 16 * 1024; | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "autorcvbuf_inc", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "autorcvbuf_inc", | ||||
CTLFLAG_RW, &sc->tt.autorcvbuf_inc, 0, | CTLFLAG_RW, &sc->tt.autorcvbuf_inc, 0, | ||||
"autorcvbuf increment"); | "autorcvbuf increment"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "timer_tick", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "timer_tick", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 0, sysctl_tp_tick, "A", | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
"TP timer tick (us)"); | sysctl_tp_tick, "A", "TP timer tick (us)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "timestamp_tick", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "timestamp_tick", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 1, sysctl_tp_tick, "A", | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 1, | ||||
"TCP timestamp tick (us)"); | sysctl_tp_tick, "A", "TCP timestamp tick (us)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "dack_tick", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "dack_tick", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, 2, sysctl_tp_tick, "A", | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 2, | ||||
"DACK tick (us)"); | sysctl_tp_tick, "A", "DACK tick (us)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "dack_timer", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "dack_timer", | ||||
CTLTYPE_UINT | CTLFLAG_RD, sc, 0, sysctl_tp_dack_timer, | CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, | ||||
"IU", "DACK timer (us)"); | sysctl_tp_dack_timer, "IU", "DACK timer (us)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_min", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_min", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_RXT_MIN, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "Minimum retransmit interval (us)"); | A_TP_RXT_MIN, sysctl_tp_timer, "LU", | ||||
"Minimum retransmit interval (us)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_max", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_max", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_RXT_MAX, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "Maximum retransmit interval (us)"); | A_TP_RXT_MAX, sysctl_tp_timer, "LU", | ||||
"Maximum retransmit interval (us)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "persist_min", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "persist_min", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_PERS_MIN, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "Persist timer min (us)"); | A_TP_PERS_MIN, sysctl_tp_timer, "LU", | ||||
"Persist timer min (us)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "persist_max", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "persist_max", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_PERS_MAX, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "Persist timer max (us)"); | A_TP_PERS_MAX, sysctl_tp_timer, "LU", | ||||
"Persist timer max (us)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_idle", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_idle", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_KEEP_IDLE, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "Keepalive idle timer (us)"); | A_TP_KEEP_IDLE, sysctl_tp_timer, "LU", | ||||
"Keepalive idle timer (us)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_interval", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_interval", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_KEEP_INTVL, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "Keepalive interval timer (us)"); | A_TP_KEEP_INTVL, sysctl_tp_timer, "LU", | ||||
"Keepalive interval timer (us)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "initial_srtt", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "initial_srtt", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_INIT_SRTT, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "Initial SRTT (us)"); | A_TP_INIT_SRTT, sysctl_tp_timer, "LU", "Initial SRTT (us)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "finwait2_timer", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "finwait2_timer", | ||||
CTLTYPE_ULONG | CTLFLAG_RD, sc, A_TP_FINWAIT2_TIMER, | CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_timer, "LU", "FINWAIT2 timer (us)"); | A_TP_FINWAIT2_TIMER, sysctl_tp_timer, "LU", | ||||
"FINWAIT2 timer (us)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "syn_rexmt_count", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "syn_rexmt_count", | ||||
CTLTYPE_UINT | CTLFLAG_RD, sc, S_SYNSHIFTMAX, | CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_shift_cnt, "IU", | S_SYNSHIFTMAX, sysctl_tp_shift_cnt, "IU", | ||||
"Number of SYN retransmissions before abort"); | "Number of SYN retransmissions before abort"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_count", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rexmt_count", | ||||
CTLTYPE_UINT | CTLFLAG_RD, sc, S_RXTSHIFTMAXR2, | CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_shift_cnt, "IU", | S_RXTSHIFTMAXR2, sysctl_tp_shift_cnt, "IU", | ||||
"Number of retransmissions before abort"); | "Number of retransmissions before abort"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_count", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "keepalive_count", | ||||
CTLTYPE_UINT | CTLFLAG_RD, sc, S_KEEPALIVEMAXR2, | CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tp_shift_cnt, "IU", | S_KEEPALIVEMAXR2, sysctl_tp_shift_cnt, "IU", | ||||
"Number of keepalive probes before abort"); | "Number of keepalive probes before abort"); | ||||
oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "rexmt_backoff", | oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "rexmt_backoff", | ||||
CTLFLAG_RD, NULL, "TOE retransmit backoffs"); | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, | ||||
"TOE retransmit backoffs"); | |||||
children = SYSCTL_CHILDREN(oid); | children = SYSCTL_CHILDREN(oid); | ||||
for (i = 0; i < 16; i++) { | for (i = 0; i < 16; i++) { | ||||
snprintf(s, sizeof(s), "%u", i); | snprintf(s, sizeof(s), "%u", i); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, s, | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, s, | ||||
CTLTYPE_UINT | CTLFLAG_RD, sc, i, sysctl_tp_backoff, | CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
"IU", "TOE retransmit backoff"); | i, sysctl_tp_backoff, "IU", | ||||
"TOE retransmit backoff"); | |||||
} | } | ||||
} | } | ||||
#endif | #endif | ||||
} | } | ||||
void | void | ||||
vi_sysctls(struct vi_info *vi) | vi_sysctls(struct vi_info *vi) | ||||
{ | { | ||||
Show All 21 Lines | |||||
&vi->first_txq, 0, "index of first tx queue"); | &vi->first_txq, 0, "index of first tx queue"); | ||||
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "rss_base", CTLFLAG_RD, NULL, | SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "rss_base", CTLFLAG_RD, NULL, | ||||
vi->rss_base, "start of RSS indirection table"); | vi->rss_base, "start of RSS indirection table"); | ||||
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "rss_size", CTLFLAG_RD, NULL, | SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "rss_size", CTLFLAG_RD, NULL, | ||||
vi->rss_size, "size of RSS indirection table"); | vi->rss_size, "size of RSS indirection table"); | ||||
if (IS_MAIN_VI(vi)) { | if (IS_MAIN_VI(vi)) { | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rsrv_noflowq", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rsrv_noflowq", | ||||
CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_noflowq, "IU", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0, | ||||
sysctl_noflowq, "IU", | |||||
"Reserve queue 0 for non-flowid packets"); | "Reserve queue 0 for non-flowid packets"); | ||||
} | } | ||||
#ifdef TCP_OFFLOAD | #ifdef TCP_OFFLOAD | ||||
if (vi->nofldrxq != 0) { | if (vi->nofldrxq != 0) { | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nofldrxq", CTLFLAG_RD, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nofldrxq", CTLFLAG_RD, | ||||
&vi->nofldrxq, 0, | &vi->nofldrxq, 0, | ||||
"# of rx queues for offloaded TCP connections"); | "# of rx queues for offloaded TCP connections"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_ofld_rxq", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_ofld_rxq", | ||||
CTLFLAG_RD, &vi->first_ofld_rxq, 0, | CTLFLAG_RD, &vi->first_ofld_rxq, 0, | ||||
"index of first TOE rx queue"); | "index of first TOE rx queue"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx_ofld", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx_ofld", | ||||
CTLTYPE_INT | CTLFLAG_RW, vi, 0, | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0, | ||||
sysctl_holdoff_tmr_idx_ofld, "I", | sysctl_holdoff_tmr_idx_ofld, "I", | ||||
"holdoff timer index for TOE queues"); | "holdoff timer index for TOE queues"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pktc_idx_ofld", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pktc_idx_ofld", | ||||
CTLTYPE_INT | CTLFLAG_RW, vi, 0, | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0, | ||||
sysctl_holdoff_pktc_idx_ofld, "I", | sysctl_holdoff_pktc_idx_ofld, "I", | ||||
"holdoff packet counter index for TOE queues"); | "holdoff packet counter index for TOE queues"); | ||||
} | } | ||||
#endif | #endif | ||||
#if defined(TCP_OFFLOAD) || defined(RATELIMIT) | #if defined(TCP_OFFLOAD) || defined(RATELIMIT) | ||||
if (vi->nofldtxq != 0) { | if (vi->nofldtxq != 0) { | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nofldtxq", CTLFLAG_RD, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nofldtxq", CTLFLAG_RD, | ||||
&vi->nofldtxq, 0, | &vi->nofldtxq, 0, | ||||
Show All 14 Lines | |||||
"index of first netmap rx queue"); | "index of first netmap rx queue"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_nm_txq", | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_nm_txq", | ||||
CTLFLAG_RD, &vi->first_nm_txq, 0, | CTLFLAG_RD, &vi->first_nm_txq, 0, | ||||
"index of first netmap tx queue"); | "index of first netmap tx queue"); | ||||
} | } | ||||
#endif | #endif | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx", | ||||
CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_holdoff_tmr_idx, "I", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0, | ||||
"holdoff timer index"); | sysctl_holdoff_tmr_idx, "I", "holdoff timer index"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pktc_idx", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pktc_idx", | ||||
CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_holdoff_pktc_idx, "I", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0, | ||||
"holdoff packet counter index"); | sysctl_holdoff_pktc_idx, "I", "holdoff packet counter index"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_rxq", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_rxq", | ||||
CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_qsize_rxq, "I", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0, | ||||
"rx queue size"); | sysctl_qsize_rxq, "I", "rx queue size"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_txq", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_txq", | ||||
CTLTYPE_INT | CTLFLAG_RW, vi, 0, sysctl_qsize_txq, "I", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, vi, 0, | ||||
"tx queue size"); | sysctl_qsize_txq, "I", "tx queue size"); | ||||
} | } | ||||
static void | static void | ||||
cxgbe_sysctls(struct port_info *pi) | cxgbe_sysctls(struct port_info *pi) | ||||
{ | { | ||||
struct sysctl_ctx_list *ctx; | struct sysctl_ctx_list *ctx; | ||||
struct sysctl_oid *oid; | struct sysctl_oid *oid; | ||||
struct sysctl_oid_list *children, *children2; | struct sysctl_oid_list *children, *children2; | ||||
struct adapter *sc = pi->adapter; | struct adapter *sc = pi->adapter; | ||||
int i; | int i; | ||||
char name[16]; | char name[16]; | ||||
static char *tc_flags = {"\20\1USER\2SYNC\3ASYNC\4ERR"}; | static char *tc_flags = {"\20\1USER\2SYNC\3ASYNC\4ERR"}; | ||||
ctx = device_get_sysctl_ctx(pi->dev); | ctx = device_get_sysctl_ctx(pi->dev); | ||||
/* | /* | ||||
* dev.cxgbe.X. | * dev.cxgbe.X. | ||||
*/ | */ | ||||
oid = device_get_sysctl_tree(pi->dev); | oid = device_get_sysctl_tree(pi->dev); | ||||
children = SYSCTL_CHILDREN(oid); | children = SYSCTL_CHILDREN(oid); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "linkdnrc", CTLTYPE_STRING | | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "linkdnrc", | ||||
CTLFLAG_RD, pi, 0, sysctl_linkdnrc, "A", "reason why link is down"); | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pi, 0, | ||||
sysctl_linkdnrc, "A", "reason why link is down"); | |||||
if (pi->port_type == FW_PORT_TYPE_BT_XAUI) { | if (pi->port_type == FW_PORT_TYPE_BT_XAUI) { | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature", | ||||
CTLTYPE_INT | CTLFLAG_RD, pi, 0, sysctl_btphy, "I", | CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pi, 0, | ||||
"PHY temperature (in Celsius)"); | sysctl_btphy, "I", "PHY temperature (in Celsius)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fw_version", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fw_version", | ||||
CTLTYPE_INT | CTLFLAG_RD, pi, 1, sysctl_btphy, "I", | CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pi, 1, | ||||
"PHY firmware version"); | sysctl_btphy, "I", "PHY firmware version"); | ||||
} | } | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_settings", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_settings", | ||||
CTLTYPE_STRING | CTLFLAG_RW, pi, 0, sysctl_pause_settings, "A", | CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pi, 0, | ||||
"PAUSE settings (bit 0 = rx_pause, 1 = tx_pause, 2 = pause_autoneg)"); | sysctl_pause_settings, "A", | ||||
"PAUSE settings (bit 0 = rx_pause, 1 = tx_pause, 2 = pause_autoneg)"); | |||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fec", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fec", | ||||
CTLTYPE_STRING | CTLFLAG_RW, pi, 0, sysctl_fec, "A", | CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pi, 0, | ||||
sysctl_fec, "A", | |||||
"FECs to use (bit 0 = RS, 1 = FC, 2 = none, 5 = auto, 6 = module)"); | "FECs to use (bit 0 = RS, 1 = FC, 2 = none, 5 = auto, 6 = module)"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "module_fec", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "module_fec", | ||||
CTLTYPE_STRING, pi, 0, sysctl_module_fec, "A", | CTLTYPE_STRING | CTLFLAG_NEEDGIANT, pi, 0, sysctl_module_fec, "A", | ||||
"FEC recommended by the cable/transceiver"); | "FEC recommended by the cable/transceiver"); | ||||
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "autoneg", | SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "autoneg", | ||||
CTLTYPE_INT | CTLFLAG_RW, pi, 0, sysctl_autoneg, "I", | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pi, 0, | ||||
sysctl_autoneg, "I", | |||||
"autonegotiation (-1 = not supported)"); | "autonegotiation (-1 = not supported)"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "pcaps", CTLFLAG_RD, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "pcaps", CTLFLAG_RD, | ||||
&pi->link_cfg.pcaps, 0, "port capabilities"); | &pi->link_cfg.pcaps, 0, "port capabilities"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "acaps", CTLFLAG_RD, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "acaps", CTLFLAG_RD, | ||||
&pi->link_cfg.acaps, 0, "advertised capabilities"); | &pi->link_cfg.acaps, 0, "advertised capabilities"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "lpacaps", CTLFLAG_RD, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "lpacaps", CTLFLAG_RD, | ||||
&pi->link_cfg.lpacaps, 0, "link partner advertised capabilities"); | &pi->link_cfg.lpacaps, 0, "link partner advertised capabilities"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "max_speed", CTLFLAG_RD, NULL, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "max_speed", CTLFLAG_RD, NULL, | ||||
port_top_speed(pi), "max speed (in Gbps)"); | port_top_speed(pi), "max speed (in Gbps)"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "mps_bg_map", CTLFLAG_RD, NULL, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "mps_bg_map", CTLFLAG_RD, NULL, | ||||
pi->mps_bg_map, "MPS buffer group map"); | pi->mps_bg_map, "MPS buffer group map"); | ||||
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "rx_e_chan_map", CTLFLAG_RD, | SYSCTL_ADD_INT(ctx, children, OID_AUTO, "rx_e_chan_map", CTLFLAG_RD, | ||||
NULL, pi->rx_e_chan_map, "TP rx e-channel map"); | NULL, pi->rx_e_chan_map, "TP rx e-channel map"); | ||||
if (sc->flags & IS_VF) | if (sc->flags & IS_VF) | ||||
return; | return; | ||||
/* | /* | ||||
* dev.(cxgbe|cxl).X.tc. | * dev.(cxgbe|cxl).X.tc. | ||||
*/ | */ | ||||
oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "tc", CTLFLAG_RD, NULL, | oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "tc", | ||||
CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, | |||||
"Tx scheduler traffic classes (cl_rl)"); | "Tx scheduler traffic classes (cl_rl)"); | ||||
children2 = SYSCTL_CHILDREN(oid); | children2 = SYSCTL_CHILDREN(oid); | ||||
SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "pktsize", | SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "pktsize", | ||||
CTLFLAG_RW, &pi->sched_params->pktsize, 0, | CTLFLAG_RW, &pi->sched_params->pktsize, 0, | ||||
"pktsize for per-flow cl-rl (0 means up to the driver )"); | "pktsize for per-flow cl-rl (0 means up to the driver )"); | ||||
SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "burstsize", | SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "burstsize", | ||||
CTLFLAG_RW, &pi->sched_params->burstsize, 0, | CTLFLAG_RW, &pi->sched_params->burstsize, 0, | ||||
"burstsize for per-flow cl-rl (0 means up to the driver)"); | "burstsize for per-flow cl-rl (0 means up to the driver)"); | ||||
for (i = 0; i < sc->chip_params->nsched_cls; i++) { | for (i = 0; i < sc->chip_params->nsched_cls; i++) { | ||||
struct tx_cl_rl_params *tc = &pi->sched_params->cl_rl[i]; | struct tx_cl_rl_params *tc = &pi->sched_params->cl_rl[i]; | ||||
snprintf(name, sizeof(name), "%d", i); | snprintf(name, sizeof(name), "%d", i); | ||||
children2 = SYSCTL_CHILDREN(SYSCTL_ADD_NODE(ctx, | children2 = SYSCTL_CHILDREN(SYSCTL_ADD_NODE(ctx, | ||||
SYSCTL_CHILDREN(oid), OID_AUTO, name, CTLFLAG_RD, NULL, | SYSCTL_CHILDREN(oid), OID_AUTO, name, | ||||
"traffic class")); | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "traffic class")); | ||||
SYSCTL_ADD_PROC(ctx, children2, OID_AUTO, "flags", | SYSCTL_ADD_PROC(ctx, children2, OID_AUTO, "flags", | ||||
CTLTYPE_STRING | CTLFLAG_RD, tc_flags, (uintptr_t)&tc->flags, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, tc_flags, | ||||
sysctl_bitfield_8b, "A", "flags"); | (uintptr_t)&tc->flags, sysctl_bitfield_8b, "A", "flags"); | ||||
SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "refcount", | SYSCTL_ADD_UINT(ctx, children2, OID_AUTO, "refcount", | ||||
CTLFLAG_RD, &tc->refcount, 0, "references to this class"); | CTLFLAG_RD, &tc->refcount, 0, "references to this class"); | ||||
SYSCTL_ADD_PROC(ctx, children2, OID_AUTO, "params", | SYSCTL_ADD_PROC(ctx, children2, OID_AUTO, "params", | ||||
CTLTYPE_STRING | CTLFLAG_RD, sc, (pi->port_id << 16) | i, | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, | ||||
sysctl_tc_params, "A", "traffic class parameters"); | (pi->port_id << 16) | i, sysctl_tc_params, "A", | ||||
"traffic class parameters"); | |||||
} | } | ||||
/* | /* | ||||
* dev.cxgbe.X.stats. | * dev.cxgbe.X.stats. | ||||
*/ | */ | ||||
oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats", CTLFLAG_RD, | oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats", | ||||
NULL, "port statistics"); | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "port statistics"); | ||||
children = SYSCTL_CHILDREN(oid); | children = SYSCTL_CHILDREN(oid); | ||||
SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "tx_parse_error", CTLFLAG_RD, | SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "tx_parse_error", CTLFLAG_RD, | ||||
&pi->tx_parse_error, 0, | &pi->tx_parse_error, 0, | ||||
"# of tx packets with invalid length or # of segments"); | "# of tx packets with invalid length or # of segments"); | ||||
#define SYSCTL_ADD_T4_REG64(pi, name, desc, reg) \ | #define SYSCTL_ADD_T4_REG64(pi, name, desc, reg) \ | ||||
SYSCTL_ADD_OID(ctx, children, OID_AUTO, name, \ | SYSCTL_ADD_OID(ctx, children, OID_AUTO, name, \ | ||||
CTLTYPE_U64 | CTLFLAG_RD, sc, reg, \ | CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, reg, \ | ||||
sysctl_handle_t4_reg64, "QU", desc) | sysctl_handle_t4_reg64, "QU", desc) | ||||
SYSCTL_ADD_T4_REG64(pi, "tx_octets", "# of octets in good frames", | SYSCTL_ADD_T4_REG64(pi, "tx_octets", "# of octets in good frames", | ||||
PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_BYTES_L)); | PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_BYTES_L)); | ||||
SYSCTL_ADD_T4_REG64(pi, "tx_frames", "total # of good frames", | SYSCTL_ADD_T4_REG64(pi, "tx_frames", "total # of good frames", | ||||
PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_FRAMES_L)); | PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_FRAMES_L)); | ||||
SYSCTL_ADD_T4_REG64(pi, "tx_bcast_frames", "# of broadcast frames", | SYSCTL_ADD_T4_REG64(pi, "tx_bcast_frames", "# of broadcast frames", | ||||
PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_BCAST_L)); | PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_BCAST_L)); | ||||
SYSCTL_ADD_T4_REG64(pi, "tx_mcast_frames", "# of multicast frames", | SYSCTL_ADD_T4_REG64(pi, "tx_mcast_frames", "# of multicast frames", | ||||
Show All 12 Lines |