d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Mark more nodes as CTLFLAG_MPSAFE or CTLFLAG_NEEDGIANT (15 of many)

Browse Source 
r357614 added CTLFLAG_NEEDGIANT to make it easier to find nodes that are
still not MPSAFE (or already are but aren’t properly marked).
Use it in preparation for a general review of all nodes.

This is non-functional change that adds annotations to SYSCTL_NODE and
SYSCTL_PROC nodes using one of the soon-to-be-required flags.
This commit is contained in:
Pawel Biernacki 2020-02-24 10:51:26 +00:00
parent 295a18d184
commit 20b91f0aa5
8 changed files with 190 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
sys/dev/e1000/if_em.c
View File

@ -459,7 +459,8 @@ static driver_t igb_if_driver = {
#define CSUM_TSO 0 #define CSUM_TSO 0
#endif #endif
static SYSCTL_NODE(_hw, OID_AUTO, em, CTLFLAG_RD, 0, "EM driver parameters"); static SYSCTL_NODE(_hw, OID_AUTO, em, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
"EM driver parameters");
static int em_disable_crc_stripping = 0; static int em_disable_crc_stripping = 0;
SYSCTL_INT(_hw_em, OID_AUTO, disable_crc_stripping, CTLFLAG_RDTUN, SYSCTL_INT(_hw_em, OID_AUTO, disable_crc_stripping, CTLFLAG_RDTUN,
@ -785,27 +786,29 @@ em_if_attach_pre(if_ctx_t ctx)
/* SYSCTL stuff */ /* SYSCTL stuff */
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "nvm", CTLTYPE_INT|CTLFLAG_RW, adapter, 0, OID_AUTO, "nvm", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
em_sysctl_nvm_info, "I", "NVM Information"); adapter, 0, em_sysctl_nvm_info, "I", "NVM Information");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "debug", CTLTYPE_INT|CTLFLAG_RW, adapter, 0, OID_AUTO, "debug", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
em_sysctl_debug_info, "I", "Debug Information"); adapter, 0, em_sysctl_debug_info, "I", "Debug Information");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "fc", CTLTYPE_INT|CTLFLAG_RW, adapter, 0, OID_AUTO, "fc", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
em_set_flowcntl, "I", "Flow Control"); adapter, 0, em_set_flowcntl, "I", "Flow Control");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "reg_dump", CTLTYPE_STRING | CTLFLAG_RD, adapter, 0, OID_AUTO, "reg_dump",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter, 0,
em_get_regs, "A", "Dump Registers"); em_get_regs, "A", "Dump Registers");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "rs_dump", CTLTYPE_INT | CTLFLAG_RW, adapter, 0, OID_AUTO, "rs_dump",
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, adapter, 0,
em_get_rs, "I", "Dump RS indexes"); em_get_rs, "I", "Dump RS indexes");
/* Determine hardware and mac info */ /* Determine hardware and mac info */
@ -1020,7 +1023,8 @@ em_if_attach_pre(if_ctx_t ctx)
hw->dev_spec.ich8lan.eee_disable = eee_setting; hw->dev_spec.ich8lan.eee_disable = eee_setting;
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "eee_control", CTLTYPE_INT|CTLFLAG_RW, OID_AUTO, "eee_control",
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, em_sysctl_eee, "I", adapter, 0, em_sysctl_eee, "I",
"Disable Energy Efficient Ethernet"); "Disable Energy Efficient Ethernet");
@ -4081,12 +4085,12 @@ em_add_hw_stats(struct adapter *adapter)
CTLFLAG_RD, &adapter->watchdog_events, CTLFLAG_RD, &adapter->watchdog_events,
"Watchdog timeouts"); "Watchdog timeouts");
SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "device_control", SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "device_control",
CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_CTRL, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
em_sysctl_reg_handler, "IU", adapter, E1000_CTRL, em_sysctl_reg_handler, "IU",
"Device Control Register"); "Device Control Register");
SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_control", SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_control",
CTLTYPE_UINT | CTLFLAG_RD, adapter, E1000_RCTL, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
em_sysctl_reg_handler, "IU", adapter, E1000_RCTL, em_sysctl_reg_handler, "IU",
"Receiver Control Register"); "Receiver Control Register");
SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "fc_high_water", SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "fc_high_water",
CTLFLAG_RD, &adapter->hw.fc.high_water, 0, CTLFLAG_RD, &adapter->hw.fc.high_water, 0,
@ -4099,18 +4103,16 @@ em_add_hw_stats(struct adapter *adapter)
struct tx_ring *txr = &tx_que->txr; struct tx_ring *txr = &tx_que->txr;
snprintf(namebuf, QUEUE_NAME_LEN, "queue_tx_%d", i); snprintf(namebuf, QUEUE_NAME_LEN, "queue_tx_%d", i);
queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
CTLFLAG_RD, NULL, "TX Queue Name"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX Queue Name");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head",
CTLTYPE_UINT | CTLFLAG_RD, adapter, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter,
E1000_TDH(txr->me), E1000_TDH(txr->me), em_sysctl_reg_handler, "IU",
em_sysctl_reg_handler, "IU",
"Transmit Descriptor Head"); "Transmit Descriptor Head");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail",
CTLTYPE_UINT | CTLFLAG_RD, adapter, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter,
E1000_TDT(txr->me), E1000_TDT(txr->me), em_sysctl_reg_handler, "IU",
em_sysctl_reg_handler, "IU",
"Transmit Descriptor Tail"); "Transmit Descriptor Tail");
SYSCTL_ADD_ULONG(ctx, queue_list, OID_AUTO, "tx_irq", SYSCTL_ADD_ULONG(ctx, queue_list, OID_AUTO, "tx_irq",
CTLFLAG_RD, &txr->tx_irq, CTLFLAG_RD, &txr->tx_irq,
@ -4121,18 +4123,16 @@ em_add_hw_stats(struct adapter *adapter)
struct rx_ring *rxr = &rx_que->rxr; struct rx_ring *rxr = &rx_que->rxr;
snprintf(namebuf, QUEUE_NAME_LEN, "queue_rx_%d", j); snprintf(namebuf, QUEUE_NAME_LEN, "queue_rx_%d", j);
queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
CTLFLAG_RD, NULL, "RX Queue Name"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX Queue Name");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head",
CTLTYPE_UINT | CTLFLAG_RD, adapter, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter,
E1000_RDH(rxr->me), E1000_RDH(rxr->me), em_sysctl_reg_handler, "IU",
em_sysctl_reg_handler, "IU",
"Receive Descriptor Head"); "Receive Descriptor Head");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail",
CTLTYPE_UINT | CTLFLAG_RD, adapter, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter,
E1000_RDT(rxr->me), E1000_RDT(rxr->me), em_sysctl_reg_handler, "IU",
em_sysctl_reg_handler, "IU",
"Receive Descriptor Tail"); "Receive Descriptor Tail");
SYSCTL_ADD_ULONG(ctx, queue_list, OID_AUTO, "rx_irq", SYSCTL_ADD_ULONG(ctx, queue_list, OID_AUTO, "rx_irq",
CTLFLAG_RD, &rxr->rx_irq, CTLFLAG_RD, &rxr->rx_irq,
@ -4142,7 +4142,7 @@ em_add_hw_stats(struct adapter *adapter)
/* MAC stats get their own sub node */ /* MAC stats get their own sub node */
stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac_stats", stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac_stats",
CTLFLAG_RD, NULL, "Statistics"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Statistics");
stat_list = SYSCTL_CHILDREN(stat_node); stat_list = SYSCTL_CHILDREN(stat_node);
SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "excess_coll", SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "excess_coll",
@ -4293,7 +4293,7 @@ em_add_hw_stats(struct adapter *adapter)
/* Interrupt Stats */ /* Interrupt Stats */
int_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "interrupts", int_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "interrupts",
CTLFLAG_RD, NULL, "Interrupt Statistics"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Interrupt Statistics");
int_list = SYSCTL_CHILDREN(int_node); int_list = SYSCTL_CHILDREN(int_node);
SYSCTL_ADD_UQUAD(ctx, int_list, OID_AUTO, "asserts", SYSCTL_ADD_UQUAD(ctx, int_list, OID_AUTO, "asserts",
@ -4435,7 +4435,7 @@ em_add_int_delay_sysctl(struct adapter *adapter, const char *name,
info->value = value; info->value = value;
SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, OID_AUTO, name, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
info, 0, em_sysctl_int_delay, "I", description); info, 0, em_sysctl_int_delay, "I", description);
} }

23
sys/dev/ixgbe/if_bypass.c
View File

@ -746,50 +746,51 @@ ixgbe_bypass_init(struct adapter *adapter)
*/ */
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "bypass_log", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "bypass_log",
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_log, "I", "Bypass Log"); adapter, 0, ixgbe_bp_log, "I", "Bypass Log");
/* All other setting are hung from the 'bypass' node */ /* All other setting are hung from the 'bypass' node */
bp_node = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev), bp_node = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "bypass", CTLFLAG_RD, NULL, "Bypass"); OID_AUTO, "bypass", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Bypass");
bp_list = SYSCTL_CHILDREN(bp_node); bp_list = SYSCTL_CHILDREN(bp_node);
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "version", CTLTYPE_INT | CTLFLAG_RD, OID_AUTO, "version", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_version, "I", "Bypass Version"); adapter, 0, ixgbe_bp_version, "I", "Bypass Version");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_set_state, "I", "Bypass State"); adapter, 0, ixgbe_bp_set_state, "I", "Bypass State");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "timeout", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "timeout", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_timeout, "I", "Bypass Timeout"); adapter, 0, ixgbe_bp_timeout, "I", "Bypass Timeout");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "main_on", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "main_on", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_main_on, "I", "Bypass Main On"); adapter, 0, ixgbe_bp_main_on, "I", "Bypass Main On");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "main_off", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "main_off", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_main_off, "I", "Bypass Main Off"); adapter, 0, ixgbe_bp_main_off, "I", "Bypass Main Off");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "aux_on", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "aux_on", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_aux_on, "I", "Bypass Aux On"); adapter, 0, ixgbe_bp_aux_on, "I", "Bypass Aux On");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "aux_off", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "aux_off", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_aux_off, "I", "Bypass Aux Off"); adapter, 0, ixgbe_bp_aux_off, "I", "Bypass Aux Off");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "wd_set", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "wd_set", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_wd_set, "I", "Set BP Watchdog"); adapter, 0, ixgbe_bp_wd_set, "I", "Set BP Watchdog");
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list, SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), bp_list,
OID_AUTO, "wd_reset", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "wd_reset", CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_bp_wd_reset, "S", "Bypass WD Reset"); adapter, 0, ixgbe_bp_wd_reset, "S", "Bypass WD Reset");
adapter->feat_en |= IXGBE_FEATURE_BYPASS; adapter->feat_en |= IXGBE_FEATURE_BYPASS;

49
sys/dev/ixgbe/if_ix.c
View File

@ -285,7 +285,8 @@ static device_method_t ixgbe_if_methods[] = {
* TUNEABLE PARAMETERS: * TUNEABLE PARAMETERS:
*/ */
static SYSCTL_NODE(_hw, OID_AUTO, ix, CTLFLAG_RD, 0, "IXGBE driver parameters"); static SYSCTL_NODE(_hw, OID_AUTO, ix, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
"IXGBE driver parameters");
static driver_t ixgbe_if_driver = { static driver_t ixgbe_if_driver = {
"ixgbe_if", ixgbe_if_methods, sizeof(struct adapter) "ixgbe_if", ixgbe_if_methods, sizeof(struct adapter)
}; };
@ -1546,14 +1547,14 @@ ixgbe_add_hw_stats(struct adapter *adapter)
struct tx_ring *txr = &tx_que->txr; struct tx_ring *txr = &tx_que->txr;
snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i); snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
CTLFLAG_RD, NULL, "Queue Name"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head",
CTLTYPE_UINT | CTLFLAG_RD, txr, 0, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, txr, 0,
ixgbe_sysctl_tdh_handler, "IU", "Transmit Descriptor Head"); ixgbe_sysctl_tdh_handler, "IU", "Transmit Descriptor Head");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_tail",
CTLTYPE_UINT | CTLFLAG_RD, txr, 0, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, txr, 0,
ixgbe_sysctl_tdt_handler, "IU", "Transmit Descriptor Tail"); ixgbe_sysctl_tdt_handler, "IU", "Transmit Descriptor Tail");
SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx", SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
CTLFLAG_RD, &txr->tso_tx, "TSO"); CTLFLAG_RD, &txr->tso_tx, "TSO");
@ -1566,21 +1567,22 @@ ixgbe_add_hw_stats(struct adapter *adapter)
struct rx_ring *rxr = &rx_que->rxr; struct rx_ring *rxr = &rx_que->rxr;
snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i); snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
CTLFLAG_RD, NULL, "Queue Name"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate",
CTLTYPE_UINT | CTLFLAG_RW, &adapter->rx_queues[i], 0, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
&adapter->rx_queues[i], 0,
ixgbe_sysctl_interrupt_rate_handler, "IU", ixgbe_sysctl_interrupt_rate_handler, "IU",
"Interrupt Rate"); "Interrupt Rate");
SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs", SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
CTLFLAG_RD, &(adapter->rx_queues[i].irqs), CTLFLAG_RD, &(adapter->rx_queues[i].irqs),
"irqs on this queue"); "irqs on this queue");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head",
CTLTYPE_UINT | CTLFLAG_RD, rxr, 0, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, rxr, 0,
ixgbe_sysctl_rdh_handler, "IU", "Receive Descriptor Head"); ixgbe_sysctl_rdh_handler, "IU", "Receive Descriptor Head");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail", SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_tail",
CTLTYPE_UINT | CTLFLAG_RD, rxr, 0, CTLTYPE_UINT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, rxr, 0,
ixgbe_sysctl_rdt_handler, "IU", "Receive Descriptor Tail"); ixgbe_sysctl_rdt_handler, "IU", "Receive Descriptor Tail");
SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets", SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets",
CTLFLAG_RD, &rxr->rx_packets, "Queue Packets Received"); CTLFLAG_RD, &rxr->rx_packets, "Queue Packets Received");
@ -1595,7 +1597,7 @@ ixgbe_add_hw_stats(struct adapter *adapter)
/* MAC stats get their own sub node */ /* MAC stats get their own sub node */
stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac_stats", stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac_stats",
CTLFLAG_RD, NULL, "MAC Statistics"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "MAC Statistics");
stat_list = SYSCTL_CHILDREN(stat_node); stat_list = SYSCTL_CHILDREN(stat_node);
SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "crc_errs", SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "crc_errs",
@ -2528,37 +2530,42 @@ ixgbe_add_device_sysctls(if_ctx_t ctx)
/* Sysctls for all devices */ /* Sysctls for all devices */
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "fc", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "fc",
CTLTYPE_INT | CTLFLAG_RW, adapter, 0, ixgbe_sysctl_flowcntl, "I", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_sysctl_flowcntl, "I",
IXGBE_SYSCTL_DESC_SET_FC); IXGBE_SYSCTL_DESC_SET_FC);
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "advertise_speed", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "advertise_speed",
CTLTYPE_INT | CTLFLAG_RW, adapter, 0, ixgbe_sysctl_advertise, "I", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_sysctl_advertise, "I",
IXGBE_SYSCTL_DESC_ADV_SPEED); IXGBE_SYSCTL_DESC_ADV_SPEED);
#ifdef IXGBE_DEBUG #ifdef IXGBE_DEBUG
/* testing sysctls (for all devices) */ /* testing sysctls (for all devices) */
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "power_state", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "power_state",
CTLTYPE_INT | CTLFLAG_RW, adapter, 0, ixgbe_sysctl_power_state, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_sysctl_power_state,
"I", "PCI Power State"); "I", "PCI Power State");
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "print_rss_config", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "print_rss_config",
CTLTYPE_STRING | CTLFLAG_RD, adapter, 0, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter, 0,
ixgbe_sysctl_print_rss_config, "A", "Prints RSS Configuration"); ixgbe_sysctl_print_rss_config, "A", "Prints RSS Configuration");
#endif #endif
/* for X550 series devices */ /* for X550 series devices */
if (hw->mac.type >= ixgbe_mac_X550) if (hw->mac.type >= ixgbe_mac_X550)
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "dmac", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "dmac",
CTLTYPE_U16 | CTLFLAG_RW, adapter, 0, ixgbe_sysctl_dmac, CTLTYPE_U16 | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_sysctl_dmac,
"I", "DMA Coalesce"); "I", "DMA Coalesce");
/* for WoL-capable devices */ /* for WoL-capable devices */
if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) {
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wol_enable", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wol_enable",
CTLTYPE_INT | CTLFLAG_RW, adapter, 0, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, adapter, 0,
ixgbe_sysctl_wol_enable, "I", "Enable/Disable Wake on LAN"); ixgbe_sysctl_wol_enable, "I", "Enable/Disable Wake on LAN");
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wufc", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wufc",
CTLTYPE_U32 | CTLFLAG_RW, adapter, 0, ixgbe_sysctl_wufc, CTLTYPE_U32 | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_sysctl_wufc,
"I", "Enable/Disable Wake Up Filters"); "I", "Enable/Disable Wake Up Filters");
} }
@ -2568,22 +2575,24 @@ ixgbe_add_device_sysctls(if_ctx_t ctx)
struct sysctl_oid_list *phy_list; struct sysctl_oid_list *phy_list;
phy_node = SYSCTL_ADD_NODE(ctx_list, child, OID_AUTO, "phy", phy_node = SYSCTL_ADD_NODE(ctx_list, child, OID_AUTO, "phy",
CTLFLAG_RD, NULL, "External PHY sysctls"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "External PHY sysctls");
phy_list = SYSCTL_CHILDREN(phy_node); phy_list = SYSCTL_CHILDREN(phy_node);
SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO, "temp", SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO, "temp",
CTLTYPE_U16 | CTLFLAG_RD, adapter, 0, ixgbe_sysctl_phy_temp, CTLTYPE_U16 | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
adapter, 0, ixgbe_sysctl_phy_temp,
"I", "Current External PHY Temperature (Celsius)"); "I", "Current External PHY Temperature (Celsius)");
SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO, SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO,
"overtemp_occurred", CTLTYPE_U16 | CTLFLAG_RD, adapter, 0, "overtemp_occurred",
CTLTYPE_U16 | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter, 0,
ixgbe_sysctl_phy_overtemp_occurred, "I", ixgbe_sysctl_phy_overtemp_occurred, "I",
"External PHY High Temperature Event Occurred"); "External PHY High Temperature Event Occurred");
} }
if (adapter->feat_cap & IXGBE_FEATURE_EEE) { if (adapter->feat_cap & IXGBE_FEATURE_EEE) {
SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "eee_state", SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "eee_state",
CTLTYPE_INT | CTLFLAG_RW, adapter, 0, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, adapter, 0,
ixgbe_sysctl_eee_state, "I", "EEE Power Save State"); ixgbe_sysctl_eee_state, "I", "EEE Power Save State");
} }
} /* ixgbe_add_device_sysctls */ } /* ixgbe_add_device_sysctls */

11
sys/dev/ixgbe/if_ixv.c
View File

@ -418,8 +418,8 @@ ixv_if_attach_pre(if_ctx_t ctx)
/* SYSCTL APIs */ /* SYSCTL APIs */
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "debug", SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "debug",
CTLTYPE_INT | CTLFLAG_RW, adapter, 0, ixv_sysctl_debug, "I", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
"Debug Info"); adapter, 0, ixv_sysctl_debug, "I", "Debug Info");
/* Determine hardware revision */ /* Determine hardware revision */
ixv_identify_hardware(ctx); ixv_identify_hardware(ctx);
@ -1803,7 +1803,7 @@ ixv_add_stats_sysctls(struct adapter *adapter)
struct tx_ring *txr = &tx_que->txr; struct tx_ring *txr = &tx_que->txr;
snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i); snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
CTLFLAG_RD, NULL, "Queue Name"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx", SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
@ -1816,7 +1816,7 @@ ixv_add_stats_sysctls(struct adapter *adapter)
struct rx_ring *rxr = &rx_que->rxr; struct rx_ring *rxr = &rx_que->rxr;
snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i); snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
CTLFLAG_RD, NULL, "Queue Name"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs", SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
@ -1830,7 +1830,8 @@ ixv_add_stats_sysctls(struct adapter *adapter)
} }
stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac", stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac",
CTLFLAG_RD, NULL, "VF Statistics (read from HW registers)"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
"VF Statistics (read from HW registers)");
stat_list = SYSCTL_CHILDREN(stat_node); stat_list = SYSCTL_CHILDREN(stat_node);
SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_rcvd", SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_rcvd",

26
sys/dev/ixl/if_iavf.c
View File

@ -201,7 +201,7 @@ static driver_t iavf_if_driver = {
** TUNEABLE PARAMETERS: ** TUNEABLE PARAMETERS:
*/ */
static SYSCTL_NODE(_hw, OID_AUTO, iavf, CTLFLAG_RD, 0, static SYSCTL_NODE(_hw, OID_AUTO, iavf, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
"iavf driver parameters"); "iavf driver parameters");
/* /*
@ -2049,23 +2049,27 @@ iavf_add_device_sysctls(struct iavf_sc *sc)
struct sysctl_oid_list *debug_list; struct sysctl_oid_list *debug_list;
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "current_speed", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "current_speed",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
sc, 0, iavf_sysctl_current_speed, "A", "Current Port Speed"); sc, 0, iavf_sysctl_current_speed, "A", "Current Port Speed");
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "tx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "tx_itr",
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
sc, 0, iavf_sysctl_tx_itr, "I", sc, 0, iavf_sysctl_tx_itr, "I",
"Immediately set TX ITR value for all queues"); "Immediately set TX ITR value for all queues");
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "rx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "rx_itr",
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
sc, 0, iavf_sysctl_rx_itr, "I", sc, 0, iavf_sysctl_rx_itr, "I",
"Immediately set RX ITR value for all queues"); "Immediately set RX ITR value for all queues");
/* Add sysctls meant to print debug information, but don't list them /* Add sysctls meant to print debug information, but don't list them
* in "sysctl -a" output. */ * in "sysctl -a" output. */
debug_node = SYSCTL_ADD_NODE(ctx, ctx_list, debug_node = SYSCTL_ADD_NODE(ctx, ctx_list,
OID_AUTO, "debug", CTLFLAG_RD | CTLFLAG_SKIP, NULL, "Debug Sysctls"); OID_AUTO, "debug", CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_NEEDGIANT,
NULL, "Debug Sysctls");
debug_list = SYSCTL_CHILDREN(debug_node); debug_list = SYSCTL_CHILDREN(debug_node);
SYSCTL_ADD_UINT(ctx, debug_list, SYSCTL_ADD_UINT(ctx, debug_list,
@ -2077,19 +2081,23 @@ iavf_add_device_sysctls(struct iavf_sc *sc)
&sc->dbg_mask, 0, "Non-shared code debug message level"); &sc->dbg_mask, 0, "Non-shared code debug message level");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "filter_list", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "filter_list",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
sc, 0, iavf_sysctl_sw_filter_list, "A", "SW Filter List"); sc, 0, iavf_sysctl_sw_filter_list, "A", "SW Filter List");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "queue_interrupt_table", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "queue_interrupt_table",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
sc, 0, iavf_sysctl_queue_interrupt_table, "A", "View MSI-X indices for TX/RX queues"); sc, 0, iavf_sysctl_queue_interrupt_table, "A", "View MSI-X indices for TX/RX queues");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "do_vf_reset", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "do_vf_reset",
CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
sc, 0, iavf_sysctl_vf_reset, "A", "Request a VF reset from PF"); sc, 0, iavf_sysctl_vf_reset, "A", "Request a VF reset from PF");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "do_vflr_reset", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "do_vflr_reset",
CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
sc, 0, iavf_sysctl_vflr_reset, "A", "Request a VFLR reset from HW"); sc, 0, iavf_sysctl_vflr_reset, "A", "Request a VFLR reset from HW");
/* Add stats sysctls */ /* Add stats sysctls */

2
sys/dev/ixl/if_ixl.c
View File

@ -206,7 +206,7 @@ static driver_t ixl_if_driver = {
** TUNEABLE PARAMETERS: ** TUNEABLE PARAMETERS:
*/ */
static SYSCTL_NODE(_hw, OID_AUTO, ixl, CTLFLAG_RD, 0, static SYSCTL_NODE(_hw, OID_AUTO, ixl, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
"ixl driver parameters"); "ixl driver parameters");
/* /*

131
sys/dev/ixl/ixl_pf_main.c
View File

@ -1632,8 +1632,8 @@ ixl_add_sysctls_mac_stats(struct sysctl_ctx_list *ctx,
struct sysctl_oid_list *child, struct sysctl_oid_list *child,
struct i40e_hw_port_stats *stats) struct i40e_hw_port_stats *stats)
{ {
struct sysctl_oid *stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac", struct sysctl_oid *stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO,
CTLFLAG_RD, NULL, "Mac Statistics"); "mac", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Mac Statistics");
struct sysctl_oid_list *stat_list = SYSCTL_CHILDREN(stat_node); struct sysctl_oid_list *stat_list = SYSCTL_CHILDREN(stat_node);
struct i40e_eth_stats *eth_stats = &stats->eth; struct i40e_eth_stats *eth_stats = &stats->eth;
@ -3121,38 +3121,45 @@ ixl_add_device_sysctls(struct ixl_pf *pf)
/* Set up sysctls */ /* Set up sysctls */
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "fc", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "fc", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_set_flowcntl, "I", IXL_SYSCTL_HELP_FC); pf, 0, ixl_sysctl_set_flowcntl, "I", IXL_SYSCTL_HELP_FC);
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "advertise_speed", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "advertise_speed",
pf, 0, ixl_sysctl_set_advertise, "I", IXL_SYSCTL_HELP_SET_ADVERTISE); CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_set_advertise, "I", IXL_SYSCTL_HELP_SET_ADVERTISE);
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "supported_speeds", CTLTYPE_INT | CTLFLAG_RD, OID_AUTO, "supported_speeds",
pf, 0, ixl_sysctl_supported_speeds, "I", IXL_SYSCTL_HELP_SUPPORTED_SPEED); CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_supported_speeds, "I", IXL_SYSCTL_HELP_SUPPORTED_SPEED);
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "current_speed", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "current_speed",
pf, 0, ixl_sysctl_current_speed, "A", "Current Port Speed"); CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_current_speed, "A", "Current Port Speed");
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "fw_version", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "fw_version",
pf, 0, ixl_sysctl_show_fw, "A", "Firmware version"); CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_show_fw, "A", "Firmware version");
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "unallocated_queues", CTLTYPE_INT | CTLFLAG_RD, OID_AUTO, "unallocated_queues",
pf, 0, ixl_sysctl_unallocated_queues, "I", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_unallocated_queues, "I",
"Queues not allocated to a PF or VF"); "Queues not allocated to a PF or VF");
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "tx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "tx_itr",
pf, 0, ixl_sysctl_pf_tx_itr, "I", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_pf_tx_itr, "I",
"Immediately set TX ITR value for all queues"); "Immediately set TX ITR value for all queues");
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "rx_itr", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "rx_itr",
pf, 0, ixl_sysctl_pf_rx_itr, "I", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_pf_rx_itr, "I",
"Immediately set RX ITR value for all queues"); "Immediately set RX ITR value for all queues");
SYSCTL_ADD_INT(ctx, ctx_list, SYSCTL_ADD_INT(ctx, ctx_list,
@ -3166,38 +3173,48 @@ ixl_add_device_sysctls(struct ixl_pf *pf)
/* Add FEC sysctls for 25G adapters */ /* Add FEC sysctls for 25G adapters */
if (i40e_is_25G_device(hw->device_id)) { if (i40e_is_25G_device(hw->device_id)) {
fec_node = SYSCTL_ADD_NODE(ctx, ctx_list, fec_node = SYSCTL_ADD_NODE(ctx, ctx_list,
OID_AUTO, "fec", CTLFLAG_RD, NULL, "FEC Sysctls"); OID_AUTO, "fec", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
"FEC Sysctls");
fec_list = SYSCTL_CHILDREN(fec_node); fec_list = SYSCTL_CHILDREN(fec_node);
SYSCTL_ADD_PROC(ctx, fec_list, SYSCTL_ADD_PROC(ctx, fec_list,
OID_AUTO, "fc_ability", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "fc_ability",
pf, 0, ixl_sysctl_fec_fc_ability, "I", "FC FEC ability enabled"); CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_fec_fc_ability, "I", "FC FEC ability enabled");
SYSCTL_ADD_PROC(ctx, fec_list, SYSCTL_ADD_PROC(ctx, fec_list,
OID_AUTO, "rs_ability", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "rs_ability",
pf, 0, ixl_sysctl_fec_rs_ability, "I", "RS FEC ability enabled"); CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_fec_rs_ability, "I", "RS FEC ability enabled");
SYSCTL_ADD_PROC(ctx, fec_list, SYSCTL_ADD_PROC(ctx, fec_list,
OID_AUTO, "fc_requested", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "fc_requested",
pf, 0, ixl_sysctl_fec_fc_request, "I", "FC FEC mode requested on link"); CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_fec_fc_request, "I",
"FC FEC mode requested on link");
SYSCTL_ADD_PROC(ctx, fec_list, SYSCTL_ADD_PROC(ctx, fec_list,
OID_AUTO, "rs_requested", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "rs_requested",
pf, 0, ixl_sysctl_fec_rs_request, "I", "RS FEC mode requested on link"); CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_fec_rs_request, "I",
"RS FEC mode requested on link");
SYSCTL_ADD_PROC(ctx, fec_list, SYSCTL_ADD_PROC(ctx, fec_list,
OID_AUTO, "auto_fec_enabled", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "auto_fec_enabled",
pf, 0, ixl_sysctl_fec_auto_enable, "I", "Let FW decide FEC ability/request modes"); CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, pf, 0,
ixl_sysctl_fec_auto_enable, "I",
"Let FW decide FEC ability/request modes");
} }
SYSCTL_ADD_PROC(ctx, ctx_list, SYSCTL_ADD_PROC(ctx, ctx_list,
OID_AUTO, "fw_lldp", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "fw_lldp", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_fw_lldp, "I", IXL_SYSCTL_HELP_FW_LLDP); pf, 0, ixl_sysctl_fw_lldp, "I", IXL_SYSCTL_HELP_FW_LLDP);
/* Add sysctls meant to print debug information, but don't list them /* Add sysctls meant to print debug information, but don't list them
* in "sysctl -a" output. */ * in "sysctl -a" output. */
debug_node = SYSCTL_ADD_NODE(ctx, ctx_list, debug_node = SYSCTL_ADD_NODE(ctx, ctx_list,
OID_AUTO, "debug", CTLFLAG_RD | CTLFLAG_SKIP, NULL, "Debug Sysctls"); OID_AUTO, "debug", CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_MPSAFE, NULL,
"Debug Sysctls");
debug_list = SYSCTL_CHILDREN(debug_node); debug_list = SYSCTL_CHILDREN(debug_node);
SYSCTL_ADD_UINT(ctx, debug_list, SYSCTL_ADD_UINT(ctx, debug_list,
@ -3209,77 +3226,95 @@ ixl_add_device_sysctls(struct ixl_pf *pf)
&pf->dbg_mask, 0, "Non-shared code debug message level"); &pf->dbg_mask, 0, "Non-shared code debug message level");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "link_status", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "link_status",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_link_status, "A", IXL_SYSCTL_HELP_LINK_STATUS); pf, 0, ixl_sysctl_link_status, "A", IXL_SYSCTL_HELP_LINK_STATUS);
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "phy_abilities", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "phy_abilities",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_phy_abilities, "A", "PHY Abilities"); pf, 0, ixl_sysctl_phy_abilities, "A", "PHY Abilities");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "filter_list", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "filter_list",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_sw_filter_list, "A", "SW Filter List"); pf, 0, ixl_sysctl_sw_filter_list, "A", "SW Filter List");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "hw_res_alloc", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "hw_res_alloc",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_hw_res_alloc, "A", "HW Resource Allocation"); pf, 0, ixl_sysctl_hw_res_alloc, "A", "HW Resource Allocation");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "switch_config", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "switch_config",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_switch_config, "A", "HW Switch Configuration"); pf, 0, ixl_sysctl_switch_config, "A", "HW Switch Configuration");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "rss_key", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "rss_key",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_hkey, "A", "View RSS key"); pf, 0, ixl_sysctl_hkey, "A", "View RSS key");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "rss_lut", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "rss_lut",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_hlut, "A", "View RSS lookup table"); pf, 0, ixl_sysctl_hlut, "A", "View RSS lookup table");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "rss_hena", CTLTYPE_ULONG | CTLFLAG_RD, OID_AUTO, "rss_hena",
CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_hena, "LU", "View enabled packet types for RSS"); pf, 0, ixl_sysctl_hena, "LU", "View enabled packet types for RSS");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "disable_fw_link_management", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "disable_fw_link_management",
CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_fw_link_management, "I", "Disable FW Link Management"); pf, 0, ixl_sysctl_fw_link_management, "I", "Disable FW Link Management");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "dump_debug_data", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "dump_debug_data",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_dump_debug_data, "A", "Dump Debug Data from FW"); pf, 0, ixl_sysctl_dump_debug_data, "A", "Dump Debug Data from FW");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "do_pf_reset", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "do_pf_reset",
CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_do_pf_reset, "I", "Tell HW to initiate a PF reset"); pf, 0, ixl_sysctl_do_pf_reset, "I", "Tell HW to initiate a PF reset");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "do_core_reset", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "do_core_reset",
CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_do_core_reset, "I", "Tell HW to initiate a CORE reset"); pf, 0, ixl_sysctl_do_core_reset, "I", "Tell HW to initiate a CORE reset");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "do_global_reset", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "do_global_reset",
CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_do_global_reset, "I", "Tell HW to initiate a GLOBAL reset"); pf, 0, ixl_sysctl_do_global_reset, "I", "Tell HW to initiate a GLOBAL reset");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "do_emp_reset", CTLTYPE_INT | CTLFLAG_WR, OID_AUTO, "do_emp_reset",
CTLTYPE_INT | CTLFLAG_WR | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_do_emp_reset, "I", pf, 0, ixl_sysctl_do_emp_reset, "I",
"(This doesn't work) Tell HW to initiate a EMP (entire firmware) reset"); "(This doesn't work) Tell HW to initiate a EMP (entire firmware) reset");
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "queue_interrupt_table", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "queue_interrupt_table",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_queue_interrupt_table, "A", "View MSI-X indices for TX/RX queues"); pf, 0, ixl_sysctl_queue_interrupt_table, "A", "View MSI-X indices for TX/RX queues");
if (pf->has_i2c) { if (pf->has_i2c) {
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "read_i2c_byte", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "read_i2c_byte",
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_read_i2c_byte, "I", IXL_SYSCTL_HELP_READ_I2C); pf, 0, ixl_sysctl_read_i2c_byte, "I", IXL_SYSCTL_HELP_READ_I2C);
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "write_i2c_byte", CTLTYPE_INT | CTLFLAG_RW, OID_AUTO, "write_i2c_byte",
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_write_i2c_byte, "I", IXL_SYSCTL_HELP_WRITE_I2C); pf, 0, ixl_sysctl_write_i2c_byte, "I", IXL_SYSCTL_HELP_WRITE_I2C);
SYSCTL_ADD_PROC(ctx, debug_list, SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "read_i2c_diag_data", CTLTYPE_STRING | CTLFLAG_RD, OID_AUTO, "read_i2c_diag_data",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
pf, 0, ixl_sysctl_read_i2c_diag_data, "A", "Dump selected diagnostic data from FW"); pf, 0, ixl_sysctl_read_i2c_diag_data, "A", "Dump selected diagnostic data from FW");
} }
} }

8
sys/dev/ixl/ixl_txrx.c
View File

@ -850,7 +850,7 @@ ixl_add_vsi_sysctls(device_t dev, struct ixl_vsi *vsi,
tree = device_get_sysctl_tree(dev); tree = device_get_sysctl_tree(dev);
child = SYSCTL_CHILDREN(tree); child = SYSCTL_CHILDREN(tree);
vsi->vsi_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, sysctl_name, vsi->vsi_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, sysctl_name,
CTLFLAG_RD, NULL, "VSI Number"); CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "VSI Number");
vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); vsi_list = SYSCTL_CHILDREN(vsi->vsi_node);
ixl_add_sysctls_eth_stats(ctx, vsi_list, &vsi->eth_stats); ixl_add_sysctls_eth_stats(ctx, vsi_list, &vsi->eth_stats);
@ -911,7 +911,8 @@ ixl_add_queues_sysctls(device_t dev, struct ixl_vsi *vsi)
bzero(queue_namebuf, sizeof(queue_namebuf)); bzero(queue_namebuf, sizeof(queue_namebuf));
snprintf(queue_namebuf, QUEUE_NAME_LEN, "rxq%02d", q); snprintf(queue_namebuf, QUEUE_NAME_LEN, "rxq%02d", q);
queue_node = SYSCTL_ADD_NODE(ctx, vsi_list, queue_node = SYSCTL_ADD_NODE(ctx, vsi_list,
OID_AUTO, queue_namebuf, CTLFLAG_RD, NULL, "RX Queue #"); OID_AUTO, queue_namebuf, CTLFLAG_RD | CTLFLAG_MPSAFE,
NULL, "RX Queue #");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
rx_que = &(vsi->rx_queues[q]); rx_que = &(vsi->rx_queues[q]);
@ -938,7 +939,8 @@ ixl_add_queues_sysctls(device_t dev, struct ixl_vsi *vsi)
bzero(queue_namebuf, sizeof(queue_namebuf)); bzero(queue_namebuf, sizeof(queue_namebuf));
snprintf(queue_namebuf, QUEUE_NAME_LEN, "txq%02d", q); snprintf(queue_namebuf, QUEUE_NAME_LEN, "txq%02d", q);
queue_node = SYSCTL_ADD_NODE(ctx, vsi_list, queue_node = SYSCTL_ADD_NODE(ctx, vsi_list,
OID_AUTO, queue_namebuf, CTLFLAG_RD, NULL, "TX Queue #"); OID_AUTO, queue_namebuf, CTLFLAG_RD | CTLFLAG_MPSAFE,
NULL, "TX Queue #");
queue_list = SYSCTL_CHILDREN(queue_node); queue_list = SYSCTL_CHILDREN(queue_node);
tx_que = &(vsi->tx_queues[q]); tx_que = &(vsi->tx_queues[q]);