| /* |
| * CDDL HEADER START |
| * |
| * The contents of this file are subject to the terms of the |
| * Common Development and Distribution License (the "License"). |
| * You may not use this file except in compliance with the License. |
| * |
| * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| * or http://www.opensolaris.org/os/licensing. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * |
| * When distributing Covered Code, include this CDDL HEADER in each |
| * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| * If applicable, add the following below this CDDL HEADER, with the |
| * fields enclosed by brackets "[]" replaced with your own identifying |
| * information: Portions Copyright [yyyy] [name of copyright owner] |
| * |
| * CDDL HEADER END |
| */ |
| |
| /* |
| * Copyright 2014 QLogic Corporation |
| * The contents of this file are subject to the terms of the |
| * QLogic End User License (the "License"). |
| * You may not use this file except in compliance with the License. |
| * |
| * You can obtain a copy of the License at |
| * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/ |
| * QLogic_End_User_Software_License.txt |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| */ |
| |
| /* |
| * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. |
| */ |
| |
| #include "bnxe.h" |
| |
| typedef struct _BnxeKstat |
| { |
| kstat_named_t umdev_hi; |
| kstat_named_t umdev_lo; |
| kstat_named_t version; |
| kstat_named_t versionFW; |
| kstat_named_t versionBC; |
| kstat_named_t chipName; |
| kstat_named_t chipID; |
| kstat_named_t devBDF; |
| kstat_named_t devID; |
| kstat_named_t multiFunction; |
| kstat_named_t multiFunctionVnics; |
| kstat_named_t macAddr; |
| kstat_named_t hwInitDone; |
| kstat_named_t clientsHw; |
| kstat_named_t clientsDevi; |
| kstat_named_t clientsBound; |
| kstat_named_t txMsgPullUp; |
| kstat_named_t intrAlloc; |
| kstat_named_t intrFired; |
| kstat_named_t timerFired; |
| kstat_named_t timerReply; |
| kstat_named_t timerNoReplyTotal; |
| kstat_named_t timerNoReplyCurrent; |
| kstat_named_t timerDone; |
| kstat_named_t workQueueInstCnt; |
| kstat_named_t workItemInstQueued; |
| kstat_named_t workItemInstError; |
| kstat_named_t workItemInstComplete; |
| kstat_named_t workItemInstHighWater; |
| kstat_named_t workQueueDelayCnt; |
| kstat_named_t workItemDelayQueued; |
| kstat_named_t workItemDelayError; |
| kstat_named_t workItemDelayComplete; |
| kstat_named_t workItemDelayHighWater; |
| kstat_named_t memAllocBlocks; |
| kstat_named_t memAllocDMAs; |
| kstat_named_t memAllocBARs; |
| } BnxeKstat; |
| |
| #define BNXE_KSTAT_SIZE (sizeof(BnxeKstat) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatLink |
| { |
| kstat_named_t clients; |
| kstat_named_t uptime; |
| kstat_named_t mtuL2; |
| kstat_named_t mtuFCOE; |
| kstat_named_t speed; |
| kstat_named_t link; |
| kstat_named_t duplex; |
| kstat_named_t pauseRx; |
| kstat_named_t pauseTx; |
| } BnxeKstatLink; |
| |
| #define BNXE_KSTAT_LINK_SIZE (sizeof(BnxeKstatLink) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatIntr |
| { |
| kstat_named_t intrAlloc; |
| kstat_named_t intrFired; |
| kstat_named_t intrWrongState; |
| kstat_named_t intrInDisabled; |
| kstat_named_t intrZeroStatus; |
| kstat_named_t sb_00; |
| kstat_named_t sb_01; |
| kstat_named_t sb_02; |
| kstat_named_t sb_03; |
| kstat_named_t sb_04; |
| kstat_named_t sb_05; |
| kstat_named_t sb_06; |
| kstat_named_t sb_07; |
| kstat_named_t sb_08; |
| kstat_named_t sb_09; |
| kstat_named_t sb_10; |
| kstat_named_t sb_11; |
| kstat_named_t sb_12; |
| kstat_named_t sb_13; |
| kstat_named_t sb_14; |
| kstat_named_t sb_15; |
| kstat_named_t sb_16; |
| kstat_named_t sb_nc_00; |
| kstat_named_t sb_nc_01; |
| kstat_named_t sb_nc_02; |
| kstat_named_t sb_nc_03; |
| kstat_named_t sb_nc_04; |
| kstat_named_t sb_nc_05; |
| kstat_named_t sb_nc_06; |
| kstat_named_t sb_nc_07; |
| kstat_named_t sb_nc_08; |
| kstat_named_t sb_nc_09; |
| kstat_named_t sb_nc_10; |
| kstat_named_t sb_nc_11; |
| kstat_named_t sb_nc_12; |
| kstat_named_t sb_nc_13; |
| kstat_named_t sb_nc_14; |
| kstat_named_t sb_nc_15; |
| kstat_named_t sb_nc_16; |
| kstat_named_t sb_poll_00; |
| kstat_named_t sb_poll_01; |
| kstat_named_t sb_poll_02; |
| kstat_named_t sb_poll_03; |
| kstat_named_t sb_poll_04; |
| kstat_named_t sb_poll_05; |
| kstat_named_t sb_poll_06; |
| kstat_named_t sb_poll_07; |
| kstat_named_t sb_poll_08; |
| kstat_named_t sb_poll_09; |
| kstat_named_t sb_poll_10; |
| kstat_named_t sb_poll_11; |
| kstat_named_t sb_poll_12; |
| kstat_named_t sb_poll_13; |
| kstat_named_t sb_poll_14; |
| kstat_named_t sb_poll_15; |
| kstat_named_t sb_poll_16; |
| kstat_named_t sb_poll_nc_00; |
| kstat_named_t sb_poll_nc_01; |
| kstat_named_t sb_poll_nc_02; |
| kstat_named_t sb_poll_nc_03; |
| kstat_named_t sb_poll_nc_04; |
| kstat_named_t sb_poll_nc_05; |
| kstat_named_t sb_poll_nc_06; |
| kstat_named_t sb_poll_nc_07; |
| kstat_named_t sb_poll_nc_08; |
| kstat_named_t sb_poll_nc_09; |
| kstat_named_t sb_poll_nc_10; |
| kstat_named_t sb_poll_nc_11; |
| kstat_named_t sb_poll_nc_12; |
| kstat_named_t sb_poll_nc_13; |
| kstat_named_t sb_poll_nc_14; |
| kstat_named_t sb_poll_nc_15; |
| kstat_named_t sb_poll_nc_16; |
| } BnxeKstatIntr; |
| |
| #define BNXE_KSTAT_INTR_SIZE (sizeof(BnxeKstatIntr) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatL2Chip |
| { |
| kstat_named_t IfHCInOctets; |
| kstat_named_t IfHCInBadOctets; |
| kstat_named_t IfHCOutOctets; |
| kstat_named_t IfHCOutBadOctets; |
| kstat_named_t IfHCOutPkts; |
| kstat_named_t IfHCInPkts; |
| kstat_named_t IfHCInUcastPkts; |
| kstat_named_t IfHCInMulticastPkts; |
| kstat_named_t IfHCInBroadcastPkts; |
| kstat_named_t IfHCOutUcastPkts; |
| kstat_named_t IfHCOutMulticastPkts; |
| kstat_named_t IfHCOutBroadcastPkts; |
| kstat_named_t IfHCInUcastOctets; |
| kstat_named_t IfHCInMulticastOctets; |
| kstat_named_t IfHCInBroadcastOctets; |
| kstat_named_t IfHCOutUcastOctets; |
| kstat_named_t IfHCOutMulticastOctets; |
| kstat_named_t IfHCOutBroadcastOctets; |
| kstat_named_t IfHCOutDiscards; |
| kstat_named_t IfHCInFalseCarrierErrors; |
| kstat_named_t Dot3StatsInternalMacTransmitErrors; |
| kstat_named_t Dot3StatsCarrierSenseErrors; |
| kstat_named_t Dot3StatsFCSErrors; |
| kstat_named_t Dot3StatsAlignmentErrors; |
| kstat_named_t Dot3StatsSingleCollisionFrames; |
| kstat_named_t Dot3StatsMultipleCollisionFrames; |
| kstat_named_t Dot3StatsDeferredTransmissions; |
| kstat_named_t Dot3StatsExcessiveCollisions; |
| kstat_named_t Dot3StatsLateCollisions; |
| kstat_named_t EtherStatsCollisions; |
| kstat_named_t EtherStatsFragments; |
| kstat_named_t EtherStatsJabbers; |
| kstat_named_t EtherStatsUndersizePkts; |
| kstat_named_t EtherStatsOverrsizePkts; |
| kstat_named_t EtherStatsTx64Octets; |
| kstat_named_t EtherStatsTx65to127Octets; |
| kstat_named_t EtherStatsTx128to255Octets; |
| kstat_named_t EtherStatsTx256to511Octets; |
| kstat_named_t EtherStatsTx512to1023Octets; |
| kstat_named_t EtherStatsTx1024to1522Octets; |
| kstat_named_t EtherStatsTxOver1522Octets; |
| kstat_named_t XonPauseFramesReceived; |
| kstat_named_t XoffPauseFramesReceived; |
| kstat_named_t OutXonSent; |
| kstat_named_t OutXoffSent; |
| kstat_named_t FlowControlDone; |
| kstat_named_t MacControlFramesReceived; |
| kstat_named_t XoffStateEntered; |
| kstat_named_t IfInFramesL2FilterDiscards; |
| kstat_named_t IfInTTL0Discards; |
| kstat_named_t IfInxxOverflowDiscards; |
| kstat_named_t IfInMBUFDiscards; |
| kstat_named_t IfInErrors; |
| kstat_named_t IfInErrorsOctets; |
| kstat_named_t IfInNoBrbBuffer; |
| kstat_named_t NigBrbPacket; |
| kstat_named_t NigBrbTruncate; |
| kstat_named_t NigFlowCtrlDiscard; |
| kstat_named_t NigFlowCtrlOctets; |
| kstat_named_t NigFlowCtrlPacket; |
| kstat_named_t NigMngDiscard; |
| kstat_named_t NigMngOctetInp; |
| kstat_named_t NigMngOctetOut; |
| kstat_named_t NigMngPacketInp; |
| kstat_named_t NigMngPacketOut; |
| kstat_named_t NigPbfOctets; |
| kstat_named_t NigPbfPacket; |
| kstat_named_t NigSafcInp; |
| } BnxeKstatL2Chip; |
| |
| #define BNXE_KSTAT_L2_CHIP_SIZE (sizeof(BnxeKstatL2Chip) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatL2Driver |
| { |
| kstat_named_t RxIPv4FragCount; |
| kstat_named_t RxIpCsErrorCount; |
| kstat_named_t RxTcpCsErrorCount; |
| kstat_named_t RxLlcSnapCount; |
| kstat_named_t RxPhyErrorCount; |
| kstat_named_t RxIpv6ExtCount; |
| kstat_named_t TxNoL2Bd; |
| kstat_named_t TxNoSqWqe; |
| kstat_named_t TxL2AssemblyBufUse; |
| } BnxeKstatL2Driver; |
| |
| #define BNXE_KSTAT_L2_DRIVER_SIZE (sizeof(BnxeKstatL2Driver) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatEthStats |
| { |
| /* lm_stats_t */ |
| kstat_named_t txFramesOk; // LM_STATS_FRAMES_XMITTED_OK |
| kstat_named_t rxFramesOk; // LM_STATS_FRAMES_RECEIVED_OK |
| kstat_named_t txErr; // LM_STATS_ERRORED_TRANSMIT_CNT |
| kstat_named_t rxErr; // LM_STATS_ERRORED_RECEIVE_CNT |
| kstat_named_t rxCrcErr; // LM_STATS_RCV_CRC_ERROR |
| kstat_named_t alignErr; // LM_STATS_ALIGNMENT_ERROR |
| kstat_named_t collisionsSingle; // LM_STATS_SINGLE_COLLISION_FRAMES |
| kstat_named_t collisionsMultiple; // LM_STATS_MULTIPLE_COLLISION_FRAMES |
| kstat_named_t framesDeferred; // LM_STATS_FRAMES_DEFERRED |
| kstat_named_t collisonsMax; // LM_STATS_MAX_COLLISIONS |
| kstat_named_t rxOverrun; // LM_STATS_RCV_OVERRUN |
| kstat_named_t txOverrun; // LM_STATS_XMIT_UNDERRUN |
| kstat_named_t txFramesUnicast; // LM_STATS_UNICAST_FRAMES_XMIT |
| kstat_named_t txFramesMulticast; // LM_STATS_MULTICAST_FRAMES_XMIT |
| kstat_named_t txFramesBroadcast; // LM_STATS_BROADCAST_FRAMES_XMIT |
| kstat_named_t rxFramesUnicast; // LM_STATS_UNICAST_FRAMES_RCV |
| kstat_named_t rxFramesMulticast; // LM_STATS_MULTICAST_FRAMES_RCV |
| kstat_named_t rxFramesBroadcast; // LM_STATS_BROADCAST_FRAMES_RCV |
| kstat_named_t rxNoBufferDrop; // LM_STATS_RCV_NO_BUFFER_DROP |
| kstat_named_t rxBytes; // LM_STATS_BYTES_RCV |
| kstat_named_t txBytes; // LM_STATS_BYTES_XMIT |
| kstat_named_t offloadIP4; // LM_STATS_IP4_OFFLOAD |
| kstat_named_t offloadTCP; // LM_STATS_TCP_OFFLOAD |
| kstat_named_t ifInDiscards; // LM_STATS_IF_IN_DISCARDS |
| kstat_named_t ifInErrors; // LM_STATS_IF_IN_ERRORS |
| kstat_named_t ifOutErrors; // LM_STATS_IF_OUT_ERRORS |
| kstat_named_t offloadIP6; // LM_STATS_IP6_OFFLOAD |
| kstat_named_t offloadTCP6; // LM_STATS_TCP6_OFFLOAD |
| kstat_named_t txDiscards; // LM_STATS_XMIT_DISCARDS |
| kstat_named_t rxBytesUnicast; // LM_STATS_DIRECTED_BYTES_RCV |
| kstat_named_t rxBytesMulticast; // LM_STATS_MULTICAST_BYTES_RCV |
| kstat_named_t rxBytesBroadcast; // LM_STATS_BROADCAST_BYTES_RCV |
| kstat_named_t txBytesUnicast; // LM_STATS_DIRECTED_BYTES_XMIT |
| kstat_named_t txBytesMulticast; // LM_STATS_MULTICAST_BYTES_XMIT |
| kstat_named_t txBytesBroadcast; // LM_STATS_BROADCAST_BYTES_XMIT |
| } BnxeKstatEthStats; |
| |
| #define BNXE_KSTAT_ETH_STATS_SIZE (sizeof(BnxeKstatEthStats) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatFcoe |
| { |
| kstat_named_t pdev_hi; |
| kstat_named_t pdev_lo; |
| kstat_named_t instance; |
| kstat_named_t macAddr; |
| kstat_named_t pwwn_hi; |
| kstat_named_t pwwn_lo; |
| kstat_named_t mtu; |
| kstat_named_t initWqeTx; |
| kstat_named_t initWqeTxErr; |
| kstat_named_t initCqeRx; |
| kstat_named_t initCqeRxErr; |
| kstat_named_t offloadConnWqeTx; |
| kstat_named_t offloadConnWqeTxErr; |
| kstat_named_t offloadConnCqeRx; |
| kstat_named_t offloadConnCqeRxErr; |
| kstat_named_t enableConnWqeTx; |
| kstat_named_t enableConnWqeTxErr; |
| kstat_named_t enableConnCqeRx; |
| kstat_named_t enableConnCqeRxErr; |
| kstat_named_t disableConnWqeTx; |
| kstat_named_t disableConnWqeTxErr; |
| kstat_named_t disableConnCqeRx; |
| kstat_named_t disableConnCqeRxErr; |
| kstat_named_t destroyConnWqeTx; |
| kstat_named_t destroyConnWqeTxErr; |
| kstat_named_t destroyConnCqeRx; |
| kstat_named_t destroyConnCqeRxErr; |
| kstat_named_t destroyWqeTx; |
| kstat_named_t destroyWqeTxErr; |
| kstat_named_t destroyCqeRx; |
| kstat_named_t destroyCqeRxErr; |
| kstat_named_t compRequestCqeRx; |
| kstat_named_t compRequestCqeRxErr; |
| kstat_named_t statWqeTx; |
| kstat_named_t statWqeTxErr; |
| kstat_named_t statCqeRx; |
| kstat_named_t statCqeRxErr; |
| } BnxeKstatFcoe; |
| |
| #define BNXE_KSTAT_FCOE_SIZE (sizeof(BnxeKstatFcoe) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatDcbx |
| { |
| kstat_named_t dcbx_sync; |
| kstat_named_t dcbx_vers; |
| kstat_named_t overwrite_settings; |
| kstat_named_t prio_tag; |
| kstat_named_t prio_tag_fcoe; |
| kstat_named_t prio_tag_iscsi; |
| kstat_named_t prio_tag_net; |
| kstat_named_t pfc; |
| kstat_named_t pfc_prio_0; |
| kstat_named_t pfc_prio_1; |
| kstat_named_t pfc_prio_2; |
| kstat_named_t pfc_prio_3; |
| kstat_named_t pfc_prio_4; |
| kstat_named_t pfc_prio_5; |
| kstat_named_t pfc_prio_6; |
| kstat_named_t pfc_prio_7; |
| kstat_named_t ets; |
| kstat_named_t ets_prio_0_pg; |
| kstat_named_t ets_prio_1_pg; |
| kstat_named_t ets_prio_2_pg; |
| kstat_named_t ets_prio_3_pg; |
| kstat_named_t ets_prio_4_pg; |
| kstat_named_t ets_prio_5_pg; |
| kstat_named_t ets_prio_6_pg; |
| kstat_named_t ets_prio_7_pg; |
| kstat_named_t ets_pg_0_bw; |
| kstat_named_t ets_pg_1_bw; |
| kstat_named_t ets_pg_2_bw; |
| kstat_named_t ets_pg_3_bw; |
| kstat_named_t ets_pg_4_bw; |
| kstat_named_t ets_pg_5_bw; |
| kstat_named_t ets_pg_6_bw; |
| kstat_named_t ets_pg_7_bw; |
| kstat_named_t lldp; |
| kstat_named_t lldp_tx_interval; |
| kstat_named_t lldp_tx_fast_interval; |
| kstat_named_t amib_apptlv_willing; |
| kstat_named_t amib_apptlv_tx; |
| kstat_named_t amib_apptlv_net_prio; |
| kstat_named_t amib_apptlv_tbl_0_prio; |
| kstat_named_t amib_apptlv_tbl_0_appid; |
| kstat_named_t amib_apptlv_tbl_1_prio; |
| kstat_named_t amib_apptlv_tbl_1_appid; |
| kstat_named_t amib_apptlv_tbl_2_prio; |
| kstat_named_t amib_apptlv_tbl_2_appid; |
| kstat_named_t amib_apptlv_tbl_3_prio; |
| kstat_named_t amib_apptlv_tbl_3_appid; |
| kstat_named_t amib_pgtlv_willing; |
| kstat_named_t amib_pgtlv_tx; |
| kstat_named_t amib_pgtlv_tc_supported; |
| kstat_named_t amib_pgtlv_ets; |
| kstat_named_t amib_pgtlv_pg_0_bw; |
| kstat_named_t amib_pgtlv_pg_1_bw; |
| kstat_named_t amib_pgtlv_pg_2_bw; |
| kstat_named_t amib_pgtlv_pg_3_bw; |
| kstat_named_t amib_pgtlv_pg_4_bw; |
| kstat_named_t amib_pgtlv_pg_5_bw; |
| kstat_named_t amib_pgtlv_pg_6_bw; |
| kstat_named_t amib_pgtlv_pg_7_bw; |
| kstat_named_t amib_pgtlv_prio_0_map; |
| kstat_named_t amib_pgtlv_prio_1_map; |
| kstat_named_t amib_pgtlv_prio_2_map; |
| kstat_named_t amib_pgtlv_prio_3_map; |
| kstat_named_t amib_pgtlv_prio_4_map; |
| kstat_named_t amib_pgtlv_prio_5_map; |
| kstat_named_t amib_pgtlv_prio_6_map; |
| kstat_named_t amib_pgtlv_prio_7_map; |
| kstat_named_t amib_pfctlv_willing; |
| kstat_named_t amib_pfctlv_tx; |
| kstat_named_t amib_pfctlv_pfc; |
| kstat_named_t amib_pfctlv_pfc_map; |
| kstat_named_t rmib_apptlv_willing; |
| kstat_named_t rmib_apptlv_tbl_0_prio; |
| kstat_named_t rmib_apptlv_tbl_0_appid; |
| kstat_named_t rmib_apptlv_tbl_1_prio; |
| kstat_named_t rmib_apptlv_tbl_1_appid; |
| kstat_named_t rmib_apptlv_tbl_2_prio; |
| kstat_named_t rmib_apptlv_tbl_2_appid; |
| kstat_named_t rmib_apptlv_tbl_3_prio; |
| kstat_named_t rmib_apptlv_tbl_3_appid; |
| kstat_named_t rmib_pgtlv_willing; |
| kstat_named_t rmib_pgtlv_tc_supported; |
| kstat_named_t rmib_pgtlv_pg_0_bw; |
| kstat_named_t rmib_pgtlv_pg_1_bw; |
| kstat_named_t rmib_pgtlv_pg_2_bw; |
| kstat_named_t rmib_pgtlv_pg_3_bw; |
| kstat_named_t rmib_pgtlv_pg_4_bw; |
| kstat_named_t rmib_pgtlv_pg_5_bw; |
| kstat_named_t rmib_pgtlv_pg_6_bw; |
| kstat_named_t rmib_pgtlv_pg_7_bw; |
| kstat_named_t rmib_pgtlv_prio_0_map; |
| kstat_named_t rmib_pgtlv_prio_1_map; |
| kstat_named_t rmib_pgtlv_prio_2_map; |
| kstat_named_t rmib_pgtlv_prio_3_map; |
| kstat_named_t rmib_pgtlv_prio_4_map; |
| kstat_named_t rmib_pgtlv_prio_5_map; |
| kstat_named_t rmib_pgtlv_prio_6_map; |
| kstat_named_t rmib_pgtlv_prio_7_map; |
| kstat_named_t rmib_pfctlv_willing; |
| kstat_named_t rmib_pfctlv_pfc_map; |
| kstat_named_t rmib_pfctlv_capable; |
| kstat_named_t lmib_apptlv_tbl_0_prio; |
| kstat_named_t lmib_apptlv_tbl_0_appid; |
| kstat_named_t lmib_apptlv_tbl_1_prio; |
| kstat_named_t lmib_apptlv_tbl_1_appid; |
| kstat_named_t lmib_apptlv_tbl_2_prio; |
| kstat_named_t lmib_apptlv_tbl_2_appid; |
| kstat_named_t lmib_apptlv_tbl_3_prio; |
| kstat_named_t lmib_apptlv_tbl_3_appid; |
| kstat_named_t lmib_apptlv_mismatch; |
| kstat_named_t lmib_pgtlv_ets; |
| kstat_named_t lmib_pgtlv_tc_supported; |
| kstat_named_t lmib_pgtlv_pg_0_bw; |
| kstat_named_t lmib_pgtlv_pg_1_bw; |
| kstat_named_t lmib_pgtlv_pg_2_bw; |
| kstat_named_t lmib_pgtlv_pg_3_bw; |
| kstat_named_t lmib_pgtlv_pg_4_bw; |
| kstat_named_t lmib_pgtlv_pg_5_bw; |
| kstat_named_t lmib_pgtlv_pg_6_bw; |
| kstat_named_t lmib_pgtlv_pg_7_bw; |
| kstat_named_t lmib_pgtlv_prio_0_map; |
| kstat_named_t lmib_pgtlv_prio_1_map; |
| kstat_named_t lmib_pgtlv_prio_2_map; |
| kstat_named_t lmib_pgtlv_prio_3_map; |
| kstat_named_t lmib_pgtlv_prio_4_map; |
| kstat_named_t lmib_pgtlv_prio_5_map; |
| kstat_named_t lmib_pgtlv_prio_6_map; |
| kstat_named_t lmib_pgtlv_prio_7_map; |
| kstat_named_t lmib_pfctlv_pfc; |
| kstat_named_t lmib_pfctlv_pfc_map; |
| kstat_named_t lmib_pfctlv_capable; |
| kstat_named_t lmib_pfctlv_mismatch; |
| kstat_named_t dcbx_frames_rx; |
| kstat_named_t dcbx_frames_tx; |
| kstat_named_t pfc_frames_rx; |
| kstat_named_t pfc_frames_tx; |
| } BnxeKstatDcbx; |
| |
| #define BNXE_KSTAT_DCBX_SIZE (sizeof(BnxeKstatDcbx) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatRxq |
| { |
| kstat_named_t rxqBdTotal; |
| kstat_named_t rxqBdLeft; |
| kstat_named_t rxqBdPageCnt; |
| kstat_named_t rxqBdsPerPage; |
| kstat_named_t rxqBdSize; |
| kstat_named_t rxqBdsSkipEop; |
| kstat_named_t rxqBdProdIdx; |
| kstat_named_t rxqBdConsIdx; |
| kstat_named_t hwRxqConIdx; |
| kstat_named_t sgeBdTotal; |
| kstat_named_t sgeBdLeft; |
| kstat_named_t sgeBdPageCnt; |
| kstat_named_t sgeBdsPerPage; |
| kstat_named_t sgeBdSize; |
| kstat_named_t sgeBdsSkipEop; |
| kstat_named_t sgeBdProdIdx; |
| kstat_named_t sgeBdConsIdx; |
| kstat_named_t rcqBdTotal; |
| kstat_named_t rcqBdLeft; |
| kstat_named_t rcqBdPageCnt; |
| kstat_named_t rcqBdsPerPage; |
| kstat_named_t rcqBdSize; |
| kstat_named_t rcqBdsSkipEop; |
| kstat_named_t rcqBdProdIdx; |
| kstat_named_t rcqBdConsIdx; |
| kstat_named_t hwRcqConIdx; |
| kstat_named_t rxFreeDescs; |
| kstat_named_t rxActiveDescs; |
| kstat_named_t rxDoneDescs; |
| kstat_named_t rxWaitingDescs; |
| kstat_named_t rxCopied; |
| kstat_named_t rxDiscards; |
| kstat_named_t rxBufUpInStack; |
| kstat_named_t rxLowWater; |
| kstat_named_t inPollMode; |
| kstat_named_t pollCnt; |
| kstat_named_t intrDisableCnt; |
| kstat_named_t intrEnableCnt; |
| kstat_named_t genNumber; |
| } BnxeKstatRxq; |
| |
| #define BNXE_KSTAT_RXQ_SIZE (sizeof(BnxeKstatRxq) / sizeof(kstat_named_t)) |
| |
| typedef struct _BnxeKstatTxq |
| { |
| kstat_named_t txBdTotal; |
| kstat_named_t txBdLeft; |
| kstat_named_t txBdPageCnt; |
| kstat_named_t txBdsPerPage; |
| kstat_named_t txBdSize; |
| kstat_named_t txBdsSkipEop; |
| kstat_named_t hwTxqConIdx; |
| kstat_named_t txPktIdx; |
| kstat_named_t txBdProdIdx; |
| kstat_named_t txBdConsIdx; |
| kstat_named_t txSentPkts; |
| kstat_named_t txFreeDesc; |
| kstat_named_t txWaitingPkts; |
| kstat_named_t txLowWater; |
| kstat_named_t txFailed; |
| kstat_named_t txDiscards; |
| kstat_named_t txRecycle; |
| kstat_named_t txCopied; |
| kstat_named_t txBlocked; |
| kstat_named_t txWait; |
| } BnxeKstatTxq; |
| |
| #define BNXE_KSTAT_TXQ_SIZE (sizeof(BnxeKstatTxq) / sizeof(kstat_named_t)) |
| |
| |
| static int BnxeKstatUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstat * pStats = (BnxeKstat *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| char buf[17]; /* 16 max for kstat string */ |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| snprintf(buf, sizeof(buf), "%p", (void *)pUM); |
| strncpy(pStats->umdev_hi.value.c, &buf[0], 8); |
| pStats->umdev_hi.value.c[8] = 0; |
| strncpy(pStats->umdev_lo.value.c, &buf[8], 8); |
| pStats->umdev_lo.value.c[8] = 0; |
| |
| strncpy(pStats->version.value.c, pUM->version, sizeof(pStats->version.value.c)); |
| strncpy(pStats->versionFW.value.c, pUM->versionFW, sizeof(pStats->versionFW.value.c)); |
| strncpy(pStats->versionBC.value.c, pUM->versionBC, sizeof(pStats->versionBC.value.c)); |
| |
| strncpy(pStats->chipName.value.c, pUM->chipName, sizeof(pStats->chipName.value.c)); |
| strncpy(pStats->chipID.value.c, pUM->chipID, sizeof(pStats->chipID.value.c)); |
| |
| strncpy(pStats->devBDF.value.c, pUM->bus_dev_func, sizeof(pStats->devBDF.value.c)); |
| strncpy(pStats->devID.value.c, pUM->vendor_device, sizeof(pStats->devID.value.c)); |
| |
| strncpy(pStats->multiFunction.value.c, |
| ((pUM->lm_dev.params.mf_mode == SINGLE_FUNCTION) ? "Single" : |
| (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_SD) ? "MF-SD" : |
| (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_SI) ? "MF-SI" : |
| (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_AFEX) ? "MF-AFEX" : |
| "Unknown"), |
| sizeof(pStats->multiFunction.value.c)); |
| pStats->multiFunctionVnics.value.ui64 = IS_MULTI_VNIC(&pUM->lm_dev) ? pLM->params.vnics_per_port : 0; |
| |
| snprintf(pStats->macAddr.value.c, 16, "%02x%02x%02x%02x%02x%02x", |
| pLM->params.mac_addr[0], pLM->params.mac_addr[1], |
| pLM->params.mac_addr[2], pLM->params.mac_addr[3], |
| pLM->params.mac_addr[4], pLM->params.mac_addr[5]); |
| |
| pStats->hwInitDone.value.ui64 = pUM->hwInitDone; |
| |
| snprintf(pStats->clientsHw.value.c, 16, BnxeClientsHw(pUM)); |
| snprintf(pStats->clientsDevi.value.c, 16, BnxeClientsDevi(pUM)); |
| snprintf(pStats->clientsBound.value.c, 16, BnxeClientsBound(pUM)); |
| |
| pStats->txMsgPullUp.value.ui64 = pUM->txMsgPullUp; |
| |
| strncpy(pStats->intrAlloc.value.c, pUM->intrAlloc, sizeof(pStats->intrAlloc.value.c)); |
| pStats->intrFired.value.ui64 = pUM->intrFired; |
| |
| pStats->timerFired.value.ui64 = pLM->vars.stats.stats_collect.timer_wakeup; |
| pStats->timerReply.value.ui64 = pLM->vars.stats.stats_collect.stats_fw.drv_counter; |
| pStats->timerNoReplyTotal.value.ui64 = pLM->vars.stats.stats_collect.stats_fw.timer_wakeup_no_completion_total; |
| pStats->timerNoReplyCurrent.value.ui64 = pLM->vars.stats.stats_collect.stats_fw.timer_wakeup_no_completion_current; |
| pStats->timerDone.value.ui64 = pLM->vars.stats.stats_collect.stats_fw.b_completion_done; |
| |
| pStats->workQueueInstCnt.value.ui64 = s_list_entry_cnt(&pUM->workqs.instq.workQueue); |
| pStats->workItemInstQueued.value.ui64 = pUM->workqs.instq.workItemQueued; |
| pStats->workItemInstError.value.ui64 = pUM->workqs.instq.workItemError; |
| pStats->workItemInstComplete.value.ui64 = pUM->workqs.instq.workItemComplete; |
| pStats->workItemInstHighWater.value.ui64 = pUM->workqs.instq.highWater; |
| |
| pStats->workQueueDelayCnt.value.ui64 = s_list_entry_cnt(&pUM->workqs.delayq.workQueue); |
| pStats->workItemDelayQueued.value.ui64 = pUM->workqs.delayq.workItemQueued; |
| pStats->workItemDelayError.value.ui64 = pUM->workqs.delayq.workItemError; |
| pStats->workItemDelayComplete.value.ui64 = pUM->workqs.delayq.workItemComplete; |
| pStats->workItemDelayHighWater.value.ui64 = pUM->workqs.delayq.highWater; |
| |
| pStats->memAllocBlocks.value.ui64 = d_list_entry_cnt(&pUM->memBlockList); |
| pStats->memAllocDMAs.value.ui64 = d_list_entry_cnt(&pUM->memDmaList); |
| pStats->memAllocBARs.value.ui64 = d_list_entry_cnt(&pUM->memRegionList); |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatLinkUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatLink * pStats = (BnxeKstatLink *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| snprintf(pStats->clients.value.c, 16, BnxeClientsBound(pUM)); |
| pStats->uptime.value.ui64 = (pUM->props.link_speed) ? |
| (ddi_get_time() - pUM->props.uptime) : 0; |
| pStats->mtuL2.value.ui64 = pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS]; |
| pStats->mtuFCOE.value.ui64 = (BNXE_FCOE(pUM)) ? |
| pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE] : |
| 0; |
| pStats->speed.value.ui64 = pUM->props.link_speed; |
| pStats->link.value.ui64 = (!pUM->props.link_speed) ? 0 : 1; |
| pStats->duplex.value.ui64 = pUM->props.link_duplex; |
| pStats->pauseRx.value.ui64 = pUM->props.link_rxpause; |
| pStats->pauseTx.value.ui64 = pUM->props.link_txpause; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatIntrUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatIntr * pStats = (BnxeKstatIntr *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| strncpy(pStats->intrAlloc.value.c, pUM->intrAlloc, sizeof(pStats->intrAlloc.value.c)); |
| pStats->intrFired.value.ui64 = pUM->intrFired; |
| pStats->intrWrongState.value.ui64 = pLM->vars.dbg_intr_in_wrong_state; |
| pStats->intrInDisabled.value.ui64 = pLM->vars.dbg_intr_in_disabled; |
| pStats->intrZeroStatus.value.ui64 = pLM->vars.dbg_intr_zero_status; |
| pStats->sb_00.value.ui64 = pUM->intrSbCnt[0]; |
| pStats->sb_01.value.ui64 = pUM->intrSbCnt[1]; |
| pStats->sb_02.value.ui64 = pUM->intrSbCnt[2]; |
| pStats->sb_03.value.ui64 = pUM->intrSbCnt[3]; |
| pStats->sb_04.value.ui64 = pUM->intrSbCnt[4]; |
| pStats->sb_05.value.ui64 = pUM->intrSbCnt[5]; |
| pStats->sb_06.value.ui64 = pUM->intrSbCnt[6]; |
| pStats->sb_07.value.ui64 = pUM->intrSbCnt[7]; |
| pStats->sb_08.value.ui64 = pUM->intrSbCnt[8]; |
| pStats->sb_09.value.ui64 = pUM->intrSbCnt[9]; |
| pStats->sb_10.value.ui64 = pUM->intrSbCnt[10]; |
| pStats->sb_11.value.ui64 = pUM->intrSbCnt[11]; |
| pStats->sb_12.value.ui64 = pUM->intrSbCnt[12]; |
| pStats->sb_13.value.ui64 = pUM->intrSbCnt[13]; |
| pStats->sb_14.value.ui64 = pUM->intrSbCnt[14]; |
| pStats->sb_15.value.ui64 = pUM->intrSbCnt[15]; |
| pStats->sb_16.value.ui64 = pUM->intrSbCnt[16]; |
| pStats->sb_nc_00.value.ui64 = pUM->intrSbNoChangeCnt[0]; |
| pStats->sb_nc_01.value.ui64 = pUM->intrSbNoChangeCnt[1]; |
| pStats->sb_nc_02.value.ui64 = pUM->intrSbNoChangeCnt[2]; |
| pStats->sb_nc_03.value.ui64 = pUM->intrSbNoChangeCnt[3]; |
| pStats->sb_nc_04.value.ui64 = pUM->intrSbNoChangeCnt[4]; |
| pStats->sb_nc_05.value.ui64 = pUM->intrSbNoChangeCnt[5]; |
| pStats->sb_nc_06.value.ui64 = pUM->intrSbNoChangeCnt[6]; |
| pStats->sb_nc_07.value.ui64 = pUM->intrSbNoChangeCnt[7]; |
| pStats->sb_nc_08.value.ui64 = pUM->intrSbNoChangeCnt[8]; |
| pStats->sb_nc_09.value.ui64 = pUM->intrSbNoChangeCnt[9]; |
| pStats->sb_nc_10.value.ui64 = pUM->intrSbNoChangeCnt[10]; |
| pStats->sb_nc_11.value.ui64 = pUM->intrSbNoChangeCnt[11]; |
| pStats->sb_nc_12.value.ui64 = pUM->intrSbNoChangeCnt[12]; |
| pStats->sb_nc_13.value.ui64 = pUM->intrSbNoChangeCnt[13]; |
| pStats->sb_nc_14.value.ui64 = pUM->intrSbNoChangeCnt[14]; |
| pStats->sb_nc_15.value.ui64 = pUM->intrSbNoChangeCnt[15]; |
| pStats->sb_nc_16.value.ui64 = pUM->intrSbNoChangeCnt[16]; |
| pStats->sb_poll_00.value.ui64 = pUM->intrSbPollCnt[0]; |
| pStats->sb_poll_01.value.ui64 = pUM->intrSbPollCnt[1]; |
| pStats->sb_poll_02.value.ui64 = pUM->intrSbPollCnt[2]; |
| pStats->sb_poll_03.value.ui64 = pUM->intrSbPollCnt[3]; |
| pStats->sb_poll_04.value.ui64 = pUM->intrSbPollCnt[4]; |
| pStats->sb_poll_05.value.ui64 = pUM->intrSbPollCnt[5]; |
| pStats->sb_poll_06.value.ui64 = pUM->intrSbPollCnt[6]; |
| pStats->sb_poll_07.value.ui64 = pUM->intrSbPollCnt[7]; |
| pStats->sb_poll_08.value.ui64 = pUM->intrSbPollCnt[8]; |
| pStats->sb_poll_09.value.ui64 = pUM->intrSbPollCnt[9]; |
| pStats->sb_poll_10.value.ui64 = pUM->intrSbPollCnt[10]; |
| pStats->sb_poll_11.value.ui64 = pUM->intrSbPollCnt[11]; |
| pStats->sb_poll_12.value.ui64 = pUM->intrSbPollCnt[12]; |
| pStats->sb_poll_13.value.ui64 = pUM->intrSbPollCnt[13]; |
| pStats->sb_poll_14.value.ui64 = pUM->intrSbPollCnt[14]; |
| pStats->sb_poll_15.value.ui64 = pUM->intrSbPollCnt[15]; |
| pStats->sb_poll_16.value.ui64 = pUM->intrSbPollCnt[16]; |
| pStats->sb_poll_nc_00.value.ui64 = pUM->intrSbPollNoChangeCnt[0]; |
| pStats->sb_poll_nc_01.value.ui64 = pUM->intrSbPollNoChangeCnt[1]; |
| pStats->sb_poll_nc_02.value.ui64 = pUM->intrSbPollNoChangeCnt[2]; |
| pStats->sb_poll_nc_03.value.ui64 = pUM->intrSbPollNoChangeCnt[3]; |
| pStats->sb_poll_nc_04.value.ui64 = pUM->intrSbPollNoChangeCnt[4]; |
| pStats->sb_poll_nc_05.value.ui64 = pUM->intrSbPollNoChangeCnt[5]; |
| pStats->sb_poll_nc_06.value.ui64 = pUM->intrSbPollNoChangeCnt[6]; |
| pStats->sb_poll_nc_07.value.ui64 = pUM->intrSbPollNoChangeCnt[7]; |
| pStats->sb_poll_nc_08.value.ui64 = pUM->intrSbPollNoChangeCnt[8]; |
| pStats->sb_poll_nc_09.value.ui64 = pUM->intrSbPollNoChangeCnt[9]; |
| pStats->sb_poll_nc_10.value.ui64 = pUM->intrSbPollNoChangeCnt[10]; |
| pStats->sb_poll_nc_11.value.ui64 = pUM->intrSbPollNoChangeCnt[11]; |
| pStats->sb_poll_nc_12.value.ui64 = pUM->intrSbPollNoChangeCnt[12]; |
| pStats->sb_poll_nc_13.value.ui64 = pUM->intrSbPollNoChangeCnt[13]; |
| pStats->sb_poll_nc_14.value.ui64 = pUM->intrSbPollNoChangeCnt[14]; |
| pStats->sb_poll_nc_15.value.ui64 = pUM->intrSbPollNoChangeCnt[15]; |
| pStats->sb_poll_nc_16.value.ui64 = pUM->intrSbPollNoChangeCnt[16]; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatL2ChipUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatL2Chip * pStats = (BnxeKstatL2Chip *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| b10_l2_chip_statistics_t b10_l2_stats; |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| lm_stats_get_l2_chip_stats(pLM, &b10_l2_stats, |
| L2_CHIP_STATISTICS_VER_NUM_1); |
| |
| pStats->IfHCInOctets.value.ui64 = b10_l2_stats.IfHCInOctets; |
| pStats->IfHCInBadOctets.value.ui64 = b10_l2_stats.IfHCInBadOctets; |
| pStats->IfHCOutOctets.value.ui64 = b10_l2_stats.IfHCOutOctets; |
| pStats->IfHCOutBadOctets.value.ui64 = b10_l2_stats.IfHCOutBadOctets; |
| pStats->IfHCOutPkts.value.ui64 = b10_l2_stats.IfHCOutPkts; |
| pStats->IfHCInPkts.value.ui64 = b10_l2_stats.IfHCInPkts; |
| pStats->IfHCInUcastPkts.value.ui64 = b10_l2_stats.IfHCInUcastPkts; |
| pStats->IfHCInMulticastPkts.value.ui64 = b10_l2_stats.IfHCInMulticastPkts; |
| pStats->IfHCInBroadcastPkts.value.ui64 = b10_l2_stats.IfHCInBroadcastPkts; |
| pStats->IfHCOutUcastPkts.value.ui64 = b10_l2_stats.IfHCOutUcastPkts; |
| pStats->IfHCOutMulticastPkts.value.ui64 = b10_l2_stats.IfHCOutMulticastPkts; |
| pStats->IfHCOutBroadcastPkts.value.ui64 = b10_l2_stats.IfHCOutBroadcastPkts; |
| pStats->IfHCInUcastOctets.value.ui64 = b10_l2_stats.IfHCInUcastOctets; |
| pStats->IfHCInMulticastOctets.value.ui64 = b10_l2_stats.IfHCInMulticastOctets; |
| pStats->IfHCInBroadcastOctets.value.ui64 = b10_l2_stats.IfHCInBroadcastOctets; |
| pStats->IfHCOutUcastOctets.value.ui64 = b10_l2_stats.IfHCOutUcastOctets; |
| pStats->IfHCOutMulticastOctets.value.ui64 = b10_l2_stats.IfHCOutMulticastOctets; |
| pStats->IfHCOutBroadcastOctets.value.ui64 = b10_l2_stats.IfHCOutBroadcastOctets; |
| pStats->IfHCOutDiscards.value.ui64 = b10_l2_stats.IfHCOutDiscards; |
| pStats->IfHCInFalseCarrierErrors.value.ui64 = b10_l2_stats.IfHCInFalseCarrierErrors; |
| pStats->Dot3StatsInternalMacTransmitErrors.value.ui64 = b10_l2_stats.Dot3StatsInternalMacTransmitErrors; |
| pStats->Dot3StatsCarrierSenseErrors.value.ui64 = b10_l2_stats.Dot3StatsCarrierSenseErrors; |
| pStats->Dot3StatsFCSErrors.value.ui64 = b10_l2_stats.Dot3StatsFCSErrors; |
| pStats->Dot3StatsAlignmentErrors.value.ui64 = b10_l2_stats.Dot3StatsAlignmentErrors; |
| pStats->Dot3StatsSingleCollisionFrames.value.ui64 = b10_l2_stats.Dot3StatsSingleCollisionFrames; |
| pStats->Dot3StatsMultipleCollisionFrames.value.ui64 = b10_l2_stats.Dot3StatsMultipleCollisionFrames; |
| pStats->Dot3StatsDeferredTransmissions.value.ui64 = b10_l2_stats.Dot3StatsDeferredTransmissions; |
| pStats->Dot3StatsExcessiveCollisions.value.ui64 = b10_l2_stats.Dot3StatsExcessiveCollisions; |
| pStats->Dot3StatsLateCollisions.value.ui64 = b10_l2_stats.Dot3StatsLateCollisions; |
| pStats->EtherStatsCollisions.value.ui64 = b10_l2_stats.EtherStatsCollisions; |
| pStats->EtherStatsFragments.value.ui64 = b10_l2_stats.EtherStatsFragments; |
| pStats->EtherStatsJabbers.value.ui64 = b10_l2_stats.EtherStatsJabbers; |
| pStats->EtherStatsUndersizePkts.value.ui64 = b10_l2_stats.EtherStatsUndersizePkts; |
| pStats->EtherStatsOverrsizePkts.value.ui64 = b10_l2_stats.EtherStatsOverrsizePkts; |
| pStats->EtherStatsTx64Octets.value.ui64 = b10_l2_stats.EtherStatsPktsTx64Octets; |
| pStats->EtherStatsTx65to127Octets.value.ui64 = b10_l2_stats.EtherStatsPktsTx65Octetsto127Octets; |
| pStats->EtherStatsTx128to255Octets.value.ui64 = b10_l2_stats.EtherStatsPktsTx128Octetsto255Octets; |
| pStats->EtherStatsTx256to511Octets.value.ui64 = b10_l2_stats.EtherStatsPktsTx256Octetsto511Octets; |
| pStats->EtherStatsTx512to1023Octets.value.ui64 = b10_l2_stats.EtherStatsPktsTx512Octetsto1023Octets; |
| pStats->EtherStatsTx1024to1522Octets.value.ui64 = b10_l2_stats.EtherStatsPktsTx1024Octetsto1522Octets; |
| pStats->EtherStatsTxOver1522Octets.value.ui64 = b10_l2_stats.EtherStatsPktsTxOver1522Octets; |
| pStats->XonPauseFramesReceived.value.ui64 = b10_l2_stats.XonPauseFramesReceived; |
| pStats->XoffPauseFramesReceived.value.ui64 = b10_l2_stats.XoffPauseFramesReceived; |
| pStats->OutXonSent.value.ui64 = b10_l2_stats.OutXonSent; |
| pStats->OutXoffSent.value.ui64 = b10_l2_stats.OutXoffSent; |
| pStats->FlowControlDone.value.ui64 = b10_l2_stats.FlowControlDone; |
| pStats->MacControlFramesReceived.value.ui64 = b10_l2_stats.MacControlFramesReceived; |
| pStats->XoffStateEntered.value.ui64 = b10_l2_stats.XoffStateEntered; |
| pStats->IfInFramesL2FilterDiscards.value.ui64 = b10_l2_stats.IfInFramesL2FilterDiscards; |
| pStats->IfInTTL0Discards.value.ui64 = b10_l2_stats.IfInTTL0Discards; |
| pStats->IfInxxOverflowDiscards.value.ui64 = b10_l2_stats.IfInxxOverflowDiscards; |
| pStats->IfInMBUFDiscards.value.ui64 = b10_l2_stats.IfInMBUFDiscards; |
| pStats->IfInErrors.value.ui64 = b10_l2_stats.IfInErrors; |
| pStats->IfInErrorsOctets.value.ui64 = b10_l2_stats.IfInErrorsOctets; |
| pStats->IfInNoBrbBuffer.value.ui64 = b10_l2_stats.IfInNoBrbBuffer; |
| pStats->NigBrbPacket.value.ui64 = b10_l2_stats.Nig_brb_packet; |
| pStats->NigBrbTruncate.value.ui64 = b10_l2_stats.Nig_brb_truncate; |
| pStats->NigFlowCtrlDiscard.value.ui64 = b10_l2_stats.Nig_flow_ctrl_discard; |
| pStats->NigFlowCtrlOctets.value.ui64 = b10_l2_stats.Nig_flow_ctrl_octets; |
| pStats->NigFlowCtrlPacket.value.ui64 = b10_l2_stats.Nig_flow_ctrl_packet; |
| pStats->NigMngDiscard.value.ui64 = b10_l2_stats.Nig_mng_discard; |
| pStats->NigMngOctetInp.value.ui64 = b10_l2_stats.Nig_mng_octet_inp; |
| pStats->NigMngOctetOut.value.ui64 = b10_l2_stats.Nig_mng_octet_out; |
| pStats->NigMngPacketInp.value.ui64 = b10_l2_stats.Nig_mng_packet_inp; |
| pStats->NigMngPacketOut.value.ui64 = b10_l2_stats.Nig_mng_packet_out; |
| pStats->NigPbfOctets.value.ui64 = b10_l2_stats.Nig_pbf_octets; |
| pStats->NigPbfPacket.value.ui64 = b10_l2_stats.Nig_pbf_packet; |
| pStats->NigSafcInp.value.ui64 = b10_l2_stats.Nig_safc_inp; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatL2DriverUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatL2Driver * pStats = (BnxeKstatL2Driver *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| b10_l2_driver_statistics_t b10_l2_stats; |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| lm_stats_get_l2_driver_stats(pLM, &b10_l2_stats); |
| |
| pStats->RxIPv4FragCount.value.ui64 = b10_l2_stats.RxIPv4FragCount; |
| pStats->RxIpCsErrorCount.value.ui64 = b10_l2_stats.RxIpCsErrorCount; |
| pStats->RxTcpCsErrorCount.value.ui64 = b10_l2_stats.RxTcpCsErrorCount; |
| pStats->RxLlcSnapCount.value.ui64 = b10_l2_stats.RxLlcSnapCount; |
| pStats->RxPhyErrorCount.value.ui64 = b10_l2_stats.RxPhyErrorCount; |
| pStats->RxIpv6ExtCount.value.ui64 = b10_l2_stats.RxIpv6ExtCount; |
| pStats->TxNoL2Bd.value.ui64 = b10_l2_stats.TxNoL2Bd; |
| pStats->TxNoSqWqe.value.ui64 = b10_l2_stats.TxNoSqWqe; |
| pStats->TxL2AssemblyBufUse.value.ui64 = b10_l2_stats.TxL2AssemblyBufUse; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatL2StatsUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatEthStats * pStats = (BnxeKstatEthStats *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| lm_get_stats(pLM, LM_STATS_FRAMES_XMITTED_OK, (u64_t *)&pStats->txFramesOk.value.ui64); |
| lm_get_stats(pLM, LM_STATS_FRAMES_RECEIVED_OK, (u64_t *)&pStats->rxFramesOk.value.ui64); |
| lm_get_stats(pLM, LM_STATS_ERRORED_TRANSMIT_CNT, (u64_t *)&pStats->txErr.value.ui64); |
| lm_get_stats(pLM, LM_STATS_ERRORED_RECEIVE_CNT, (u64_t *)&pStats->rxErr.value.ui64); |
| lm_get_stats(pLM, LM_STATS_RCV_CRC_ERROR, (u64_t *)&pStats->rxCrcErr.value.ui64); |
| lm_get_stats(pLM, LM_STATS_ALIGNMENT_ERROR, (u64_t *)&pStats->alignErr.value.ui64); |
| lm_get_stats(pLM, LM_STATS_SINGLE_COLLISION_FRAMES, (u64_t *)&pStats->collisionsSingle.value.ui64); |
| lm_get_stats(pLM, LM_STATS_MULTIPLE_COLLISION_FRAMES, (u64_t *)&pStats->collisionsMultiple.value.ui64); |
| lm_get_stats(pLM, LM_STATS_FRAMES_DEFERRED, (u64_t *)&pStats->framesDeferred.value.ui64); |
| lm_get_stats(pLM, LM_STATS_MAX_COLLISIONS, (u64_t *)&pStats->collisonsMax.value.ui64); |
| lm_get_stats(pLM, LM_STATS_RCV_OVERRUN, (u64_t *)&pStats->rxOverrun.value.ui64); |
| lm_get_stats(pLM, LM_STATS_XMIT_UNDERRUN, (u64_t *)&pStats->txOverrun.value.ui64); |
| lm_get_stats(pLM, LM_STATS_UNICAST_FRAMES_XMIT, (u64_t *)&pStats->txFramesUnicast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_MULTICAST_FRAMES_XMIT, (u64_t *)&pStats->txFramesMulticast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_BROADCAST_FRAMES_XMIT, (u64_t *)&pStats->txFramesBroadcast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_UNICAST_FRAMES_RCV, (u64_t *)&pStats->rxFramesUnicast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_MULTICAST_FRAMES_RCV, (u64_t *)&pStats->rxFramesMulticast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_BROADCAST_FRAMES_RCV, (u64_t *)&pStats->rxFramesBroadcast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_RCV_NO_BUFFER_DROP, (u64_t *)&pStats->rxNoBufferDrop.value.ui64); |
| lm_get_stats(pLM, LM_STATS_BYTES_RCV, (u64_t *)&pStats->rxBytes.value.ui64); |
| lm_get_stats(pLM, LM_STATS_BYTES_XMIT, (u64_t *)&pStats->txBytes.value.ui64); |
| lm_get_stats(pLM, LM_STATS_IP4_OFFLOAD, (u64_t *)&pStats->offloadIP4.value.ui64); |
| lm_get_stats(pLM, LM_STATS_TCP_OFFLOAD, (u64_t *)&pStats->offloadTCP.value.ui64); |
| lm_get_stats(pLM, LM_STATS_IF_IN_DISCARDS, (u64_t *)&pStats->ifInDiscards.value.ui64); |
| lm_get_stats(pLM, LM_STATS_IF_IN_ERRORS, (u64_t *)&pStats->ifInErrors.value.ui64); |
| lm_get_stats(pLM, LM_STATS_IF_OUT_ERRORS, (u64_t *)&pStats->ifOutErrors.value.ui64); |
| lm_get_stats(pLM, LM_STATS_IP6_OFFLOAD, (u64_t *)&pStats->offloadIP6.value.ui64); |
| lm_get_stats(pLM, LM_STATS_TCP6_OFFLOAD, (u64_t *)&pStats->offloadTCP6.value.ui64); |
| lm_get_stats(pLM, LM_STATS_XMIT_DISCARDS, (u64_t *)&pStats->txDiscards.value.ui64); |
| lm_get_stats(pLM, LM_STATS_DIRECTED_BYTES_RCV, (u64_t *)&pStats->rxBytesUnicast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_MULTICAST_BYTES_RCV, (u64_t *)&pStats->rxBytesMulticast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_BROADCAST_BYTES_RCV, (u64_t *)&pStats->rxBytesBroadcast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_DIRECTED_BYTES_XMIT, (u64_t *)&pStats->txBytesUnicast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_MULTICAST_BYTES_XMIT, (u64_t *)&pStats->txBytesMulticast.value.ui64); |
| lm_get_stats(pLM, LM_STATS_BROADCAST_BYTES_XMIT, (u64_t *)&pStats->txBytesBroadcast.value.ui64); |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatFcoeUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatFcoe * pStats = (BnxeKstatFcoe *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| char buf[17]; /* 16 max for kstat string */ |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| if (pUM->fcoe.pDev) |
| { |
| snprintf(buf, sizeof(buf), "%p", (void *)pUM->fcoe.pDev); |
| strncpy(pStats->pdev_hi.value.c, &buf[0], 8); |
| pStats->pdev_hi.value.c[8] = 0; |
| strncpy(pStats->pdev_lo.value.c, &buf[8], 8); |
| pStats->pdev_lo.value.c[8] = 0; |
| |
| snprintf(pStats->instance.value.c, 16, "bnxef%d", |
| ddi_get_instance(pUM->fcoe.pDev)); |
| |
| if ((pUM->fcoe.wwn.fcp_pwwn[0] == 0) && |
| (pUM->fcoe.wwn.fcp_pwwn[1] == 0) && |
| (pUM->fcoe.wwn.fcp_pwwn[2] == 0) && |
| (pUM->fcoe.wwn.fcp_pwwn[3] == 0) && |
| (pUM->fcoe.wwn.fcp_pwwn[4] == 0) && |
| (pUM->fcoe.wwn.fcp_pwwn[5] == 0) && |
| (pUM->fcoe.wwn.fcp_pwwn[6] == 0) && |
| (pUM->fcoe.wwn.fcp_pwwn[7] == 0)) |
| { |
| snprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x%02x%02x", |
| 0x20, 0x00, |
| pLM->hw_info.fcoe_mac_addr[0], |
| pLM->hw_info.fcoe_mac_addr[1], |
| pLM->hw_info.fcoe_mac_addr[2], |
| pLM->hw_info.fcoe_mac_addr[3], |
| pLM->hw_info.fcoe_mac_addr[4], |
| pLM->hw_info.fcoe_mac_addr[5]); |
| } |
| else |
| { |
| snprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x%02x%02x", |
| pUM->fcoe.wwn.fcp_pwwn[0], |
| pUM->fcoe.wwn.fcp_pwwn[1], |
| pUM->fcoe.wwn.fcp_pwwn[2], |
| pUM->fcoe.wwn.fcp_pwwn[3], |
| pUM->fcoe.wwn.fcp_pwwn[4], |
| pUM->fcoe.wwn.fcp_pwwn[5], |
| pUM->fcoe.wwn.fcp_pwwn[7], |
| pUM->fcoe.wwn.fcp_pwwn[7]); |
| } |
| strncpy(pStats->pwwn_hi.value.c, &buf[0], 8); |
| pStats->pwwn_hi.value.c[8] = 0; |
| strncpy(pStats->pwwn_lo.value.c, &buf[8], 8); |
| pStats->pwwn_lo.value.c[8] = 0; |
| } |
| else |
| { |
| strncpy(pStats->pdev_hi.value.c, "none", sizeof(pStats->pdev_hi.value.c)); |
| strncpy(pStats->pdev_lo.value.c, "none", sizeof(pStats->pdev_lo.value.c)); |
| strncpy(pStats->instance.value.c, "none", sizeof(pStats->instance.value.c)); |
| strncpy(pStats->pwwn_hi.value.c, "none", sizeof(pStats->pwwn_hi.value.c)); |
| strncpy(pStats->pwwn_lo.value.c, "none", sizeof(pStats->pwwn_lo.value.c)); |
| } |
| |
| snprintf(pStats->macAddr.value.c, 16, "%02x%02x%02x%02x%02x%02x", |
| pLM->hw_info.fcoe_mac_addr[0], pLM->hw_info.fcoe_mac_addr[1], |
| pLM->hw_info.fcoe_mac_addr[2], pLM->hw_info.fcoe_mac_addr[3], |
| pLM->hw_info.fcoe_mac_addr[4], pLM->hw_info.fcoe_mac_addr[5]); |
| |
| pStats->mtu.value.ui64 = pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE]; |
| pStats->initWqeTx.value.ui64 = pUM->fcoe.stats.initWqeTx; |
| pStats->initWqeTxErr.value.ui64 = pUM->fcoe.stats.initWqeTxErr; |
| pStats->initCqeRx.value.ui64 = pUM->fcoe.stats.initCqeRx; |
| pStats->initCqeRxErr.value.ui64 = pUM->fcoe.stats.initCqeRxErr; |
| pStats->offloadConnWqeTx.value.ui64 = pUM->fcoe.stats.offloadConnWqeTx; |
| pStats->offloadConnWqeTxErr.value.ui64 = pUM->fcoe.stats.offloadConnWqeTxErr; |
| pStats->offloadConnCqeRx.value.ui64 = pUM->fcoe.stats.offloadConnCqeRx; |
| pStats->offloadConnCqeRxErr.value.ui64 = pUM->fcoe.stats.offloadConnCqeRxErr; |
| pStats->enableConnWqeTx.value.ui64 = pUM->fcoe.stats.enableConnWqeTx; |
| pStats->enableConnWqeTxErr.value.ui64 = pUM->fcoe.stats.enableConnWqeTxErr; |
| pStats->enableConnCqeRx.value.ui64 = pUM->fcoe.stats.enableConnCqeRx; |
| pStats->enableConnCqeRxErr.value.ui64 = pUM->fcoe.stats.enableConnCqeRxErr; |
| pStats->disableConnWqeTx.value.ui64 = pUM->fcoe.stats.disableConnWqeTx; |
| pStats->disableConnWqeTxErr.value.ui64 = pUM->fcoe.stats.disableConnWqeTxErr; |
| pStats->disableConnCqeRx.value.ui64 = pUM->fcoe.stats.disableConnCqeRx; |
| pStats->disableConnCqeRxErr.value.ui64 = pUM->fcoe.stats.disableConnCqeRxErr; |
| pStats->destroyConnWqeTx.value.ui64 = pUM->fcoe.stats.destroyConnWqeTx; |
| pStats->destroyConnWqeTxErr.value.ui64 = pUM->fcoe.stats.destroyConnWqeTxErr; |
| pStats->destroyConnCqeRx.value.ui64 = pUM->fcoe.stats.destroyConnCqeRx; |
| pStats->destroyConnCqeRxErr.value.ui64 = pUM->fcoe.stats.destroyConnCqeRxErr; |
| pStats->destroyWqeTx.value.ui64 = pUM->fcoe.stats.destroyWqeTx; |
| pStats->destroyWqeTxErr.value.ui64 = pUM->fcoe.stats.destroyWqeTxErr; |
| pStats->destroyCqeRx.value.ui64 = pUM->fcoe.stats.destroyCqeRx; |
| pStats->destroyCqeRxErr.value.ui64 = pUM->fcoe.stats.destroyCqeRxErr; |
| pStats->compRequestCqeRx.value.ui64 = pUM->fcoe.stats.compRequestCqeRx; |
| pStats->compRequestCqeRxErr.value.ui64 = pUM->fcoe.stats.compRequestCqeRxErr; |
| pStats->statWqeTx.value.ui64 = pUM->fcoe.stats.statWqeTx; |
| pStats->statWqeTxErr.value.ui64 = pUM->fcoe.stats.statWqeTxErr; |
| pStats->statCqeRx.value.ui64 = pUM->fcoe.stats.statCqeRx; |
| pStats->statCqeRxErr.value.ui64 = pUM->fcoe.stats.statCqeRxErr; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int count_trailing_zeros(int number) |
| { |
| int x, y, z; |
| |
| x = y = z = 0; |
| |
| for (y = 7; y >= 0; y--) |
| { |
| x = number / (1 << y); |
| number = number - x * (1 << y); |
| z++; |
| |
| if (x == 1) |
| { |
| z = 0; |
| } |
| } |
| |
| /* Add fix for all zero value */ |
| if (z == 8) |
| { |
| z = 0; |
| } |
| |
| return z; |
| } |
| |
| |
| static int BnxeKstatDcbxUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatDcbx * pStats = (BnxeKstatDcbx *)kstats->ks_data; |
| um_device_t * pUM = (um_device_t *)kstats->ks_private; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| b10_lldp_params_get_t lldp_params; |
| b10_dcbx_params_get_t dcbx_params; |
| int fcoe_priority = -1; |
| int iscsi_priority = -1; |
| admin_priority_app_table_t * app_table; |
| char buf[17]; /* 16 max for kstat string */ |
| int i; |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| lm_dcbx_lldp_read_params(pLM, &lldp_params); |
| lm_dcbx_read_params(pLM, &dcbx_params); |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| snprintf(pStats->dcbx_sync.value.c, 16, "%s", |
| (!dcbx_params.config_dcbx_params.dcb_enable) ? "disabled" : |
| (dcbx_params.dcb_current_oper_state_bitmap & |
| DCBX_CURRENT_STATE_IS_SYNC) ? "IN SYNC" : "OUT OF SYNC"); |
| |
| snprintf(pStats->dcbx_vers.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_dcbx_version) ? |
| "IEEE" : "CEE"); |
| |
| snprintf(pStats->overwrite_settings.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.overwrite_settings) ? |
| "yes" : "no"); |
| |
| if (dcbx_params.dcb_current_oper_state_bitmap & |
| PRIORITY_TAGGING_IS_CURRENTLY_OPERATIONAL) |
| { |
| snprintf(pStats->prio_tag.value.c, 16, "operational"); |
| |
| app_table = dcbx_params.local_priority_app_table; |
| |
| for (i = 0; i <= 3; i++) |
| { |
| if (app_table[i].valid) |
| { |
| if ((app_table[i].traffic_type == TRAFFIC_TYPE_ETH) && |
| (app_table[i].app_id == 0x8906)) |
| { |
| fcoe_priority = count_trailing_zeros(app_table[i].priority); |
| } |
| |
| if ((app_table[i].traffic_type != TRAFFIC_TYPE_ETH) && |
| (app_table[i].app_id == 3260)) |
| { |
| iscsi_priority = count_trailing_zeros(app_table[i].priority); |
| } |
| } |
| } |
| |
| snprintf(pStats->prio_tag_fcoe.value.c, 16, "%d", fcoe_priority); |
| snprintf(pStats->prio_tag_iscsi.value.c, 16, "%d", iscsi_priority); |
| snprintf(pStats->prio_tag_net.value.c, 16, "%d", |
| dcbx_params.config_dcbx_params.admin_default_priority); |
| } |
| else |
| { |
| snprintf(pStats->prio_tag.value.c, 16, "not operational"); |
| |
| snprintf(pStats->prio_tag_fcoe.value.c, 16, "-"); |
| snprintf(pStats->prio_tag_iscsi.value.c, 16, "-"); |
| snprintf(pStats->prio_tag_net.value.c, 16, "-"); |
| } |
| |
| if (dcbx_params.dcb_current_oper_state_bitmap & |
| PFC_IS_CURRENTLY_OPERATIONAL) |
| { |
| snprintf(pStats->pfc.value.c, 16, "operational"); |
| |
| #define GET_PFC_PRIO(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%s", \ |
| ((dcbx_params.local_pfc_bitmap >> (p)) & 1) ? \ |
| "enabled" : "disabled") |
| |
| GET_PFC_PRIO(pfc_prio_0, 0); |
| GET_PFC_PRIO(pfc_prio_1, 1); |
| GET_PFC_PRIO(pfc_prio_2, 2); |
| GET_PFC_PRIO(pfc_prio_3, 3); |
| GET_PFC_PRIO(pfc_prio_4, 4); |
| GET_PFC_PRIO(pfc_prio_5, 5); |
| GET_PFC_PRIO(pfc_prio_6, 6); |
| GET_PFC_PRIO(pfc_prio_7, 7); |
| } |
| else |
| { |
| snprintf(pStats->pfc.value.c, 16, "not operational"); |
| |
| #define NO_PFC_PRIO(f) \ |
| snprintf(pStats->f.value.c, 16, "-") |
| |
| NO_PFC_PRIO(pfc_prio_0); |
| NO_PFC_PRIO(pfc_prio_1); |
| NO_PFC_PRIO(pfc_prio_2); |
| NO_PFC_PRIO(pfc_prio_3); |
| NO_PFC_PRIO(pfc_prio_4); |
| NO_PFC_PRIO(pfc_prio_5); |
| NO_PFC_PRIO(pfc_prio_6); |
| NO_PFC_PRIO(pfc_prio_7); |
| } |
| |
| if (dcbx_params.dcb_current_oper_state_bitmap & |
| ETS_IS_CURRENTLY_OPERATIONAL) |
| { |
| snprintf(pStats->ets.value.c, 16, "operational"); |
| |
| #define GET_PRIO_PG(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.local_configuration_ets_pg[p]) |
| |
| GET_PRIO_PG(ets_prio_0_pg, 0); |
| GET_PRIO_PG(ets_prio_1_pg, 1); |
| GET_PRIO_PG(ets_prio_2_pg, 2); |
| GET_PRIO_PG(ets_prio_3_pg, 3); |
| GET_PRIO_PG(ets_prio_4_pg, 4); |
| GET_PRIO_PG(ets_prio_5_pg, 5); |
| GET_PRIO_PG(ets_prio_6_pg, 6); |
| GET_PRIO_PG(ets_prio_7_pg, 7); |
| |
| #define GET_PG_BW(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.local_configuration_bw_percentage[p]) |
| |
| GET_PG_BW(ets_pg_0_bw, 0); |
| GET_PG_BW(ets_pg_1_bw, 1); |
| GET_PG_BW(ets_pg_2_bw, 2); |
| GET_PG_BW(ets_pg_3_bw, 3); |
| GET_PG_BW(ets_pg_4_bw, 4); |
| GET_PG_BW(ets_pg_5_bw, 5); |
| GET_PG_BW(ets_pg_6_bw, 6); |
| GET_PG_BW(ets_pg_7_bw, 7); |
| } |
| else |
| { |
| snprintf(pStats->ets.value.c, 16, "not operational"); |
| |
| #define NO_PRIO_PG(f) \ |
| snprintf(pStats->f.value.c, 16, "-") |
| |
| NO_PRIO_PG(ets_prio_0_pg); |
| NO_PRIO_PG(ets_prio_1_pg); |
| NO_PRIO_PG(ets_prio_2_pg); |
| NO_PRIO_PG(ets_prio_3_pg); |
| NO_PRIO_PG(ets_prio_4_pg); |
| NO_PRIO_PG(ets_prio_5_pg); |
| NO_PRIO_PG(ets_prio_6_pg); |
| NO_PRIO_PG(ets_prio_7_pg); |
| |
| #define NO_PG_BW(f) \ |
| snprintf(pStats->f.value.c, 16, "-") |
| |
| NO_PG_BW(ets_pg_0_bw); |
| NO_PG_BW(ets_pg_1_bw); |
| NO_PG_BW(ets_pg_2_bw); |
| NO_PG_BW(ets_pg_3_bw); |
| NO_PG_BW(ets_pg_4_bw); |
| NO_PG_BW(ets_pg_5_bw); |
| NO_PG_BW(ets_pg_6_bw); |
| NO_PG_BW(ets_pg_7_bw); |
| } |
| |
| if (lldp_params.admin_status && (lldp_params.admin_status != LLDP_DISABLED)) |
| { |
| snprintf(pStats->lldp.value.c, 16, "%s", |
| (lldp_params.admin_status == LLDP_TX_ONLY) ? "tx only" : |
| (lldp_params.admin_status == LLDP_RX_ONLY) ? "rx only" : |
| (lldp_params.admin_status == LLDP_TX_RX) ? "tx and rx" : |
| "unknown"); |
| snprintf(pStats->lldp_tx_interval.value.c, 16, "%d seconds", |
| lldp_params.config_lldp_params.msg_tx_interval); |
| snprintf(pStats->lldp_tx_fast_interval.value.c, 16, "%d seconds", |
| lldp_params.config_lldp_params.msg_fast_tx); |
| } |
| else |
| { |
| snprintf(pStats->lldp.value.c, 16, "disabled"); |
| snprintf(pStats->lldp_tx_interval.value.c, 16, "-"); |
| snprintf(pStats->lldp_tx_fast_interval.value.c, 16, "-"); |
| } |
| |
| /* -------------------- ADMIN MIB -------------------- */ |
| |
| snprintf(pStats->amib_apptlv_willing.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_app_priority_willing) ? |
| "willing" : "not willing"); |
| snprintf(pStats->amib_apptlv_tx.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_application_priority_tx_enable) ? |
| "enabled" : "disabled"); |
| snprintf(pStats->amib_apptlv_net_prio.value.c, 16, "%d", |
| dcbx_params.config_dcbx_params.admin_default_priority); |
| |
| #define GET_PRIO_APP_TABLE(table, f1, f2) \ |
| if (table.valid) \ |
| { \ |
| snprintf(pStats->f1.value.c, 16, "%d", \ |
| count_trailing_zeros(table.priority)); \ |
| snprintf(pStats->f2.value.c, 16, \ |
| (table.traffic_type == TRAFFIC_TYPE_ETH) ? \ |
| "ether=0x%x" : "port=%d", \ |
| table.app_id); \ |
| } \ |
| else \ |
| { \ |
| snprintf(pStats->f1.value.c, 16, "-"); \ |
| snprintf(pStats->f2.value.c, 16, "-"); \ |
| } |
| |
| GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params. |
| admin_priority_app_table[0], |
| amib_apptlv_tbl_0_prio, |
| amib_apptlv_tbl_0_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params. |
| admin_priority_app_table[1], |
| amib_apptlv_tbl_1_prio, |
| amib_apptlv_tbl_1_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params. |
| admin_priority_app_table[2], |
| amib_apptlv_tbl_2_prio, |
| amib_apptlv_tbl_2_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params. |
| admin_priority_app_table[3], |
| amib_apptlv_tbl_3_prio, |
| amib_apptlv_tbl_3_appid); |
| |
| snprintf(pStats->amib_pgtlv_willing.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_ets_willing) ? |
| "willing" : "not willing"); |
| snprintf(pStats->amib_pgtlv_tx.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_ets_configuration_tx_enable) ? |
| "enabled" : "disabled"); |
| snprintf(pStats->amib_pgtlv_tc_supported.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_tc_supported_tx_enable) ? |
| "advertised" : "not advertised"); |
| snprintf(pStats->amib_pgtlv_ets.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_ets_enable) ? |
| "enabled" : "disabled"); |
| |
| #define AMIB_GET_PG_TLV_BW(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.config_dcbx_params. \ |
| admin_configuration_bw_percentage[p]) |
| |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_0_bw, 0); |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_1_bw, 1); |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_2_bw, 2); |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_3_bw, 3); |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_4_bw, 4); |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_5_bw, 5); |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_6_bw, 6); |
| AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_7_bw, 7); |
| |
| #define AMIB_GET_PG_TLV_MAP(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.config_dcbx_params. \ |
| admin_configuration_ets_pg[p]) |
| |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_0_map, 0); |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_1_map, 1); |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_2_map, 2); |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_3_map, 3); |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_4_map, 4); |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_5_map, 5); |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_6_map, 6); |
| AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_7_map, 7); |
| |
| snprintf(pStats->amib_pfctlv_willing.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_pfc_willing) ? |
| "willing" : "not willing"); |
| snprintf(pStats->amib_pfctlv_tx.value.c, 16, "%s", |
| (dcbx_params.config_dcbx_params.admin_pfc_tx_enable) ? |
| "enabled" : "disabled"); |
| |
| if (dcbx_params.config_dcbx_params.admin_pfc_enable) |
| { |
| snprintf(pStats->amib_pfctlv_pfc.value.c, 16, "enabled"); |
| snprintf(pStats->amib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d", |
| (dcbx_params.config_dcbx_params.admin_pfc_bitmap % 2), |
| ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 2) % 2), |
| ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 4) % 2), |
| ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 8) % 2), |
| ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 16) % 2), |
| ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 32) % 2), |
| ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 64) % 2), |
| ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 128) % 2)); |
| } |
| else |
| { |
| snprintf(pStats->amib_pfctlv_pfc.value.c, 16, "disabled"); |
| snprintf(pStats->amib_pfctlv_pfc_map.value.c, 16, "-"); |
| } |
| |
| /* -------------------- REMOTE MIB -------------------- */ |
| |
| snprintf(pStats->rmib_apptlv_willing.value.c, 16, "%s", |
| (dcbx_params.remote_app_priority_willing) ? |
| "willing" : "not willing"); |
| |
| GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[0], |
| rmib_apptlv_tbl_0_prio, |
| rmib_apptlv_tbl_0_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[1], |
| rmib_apptlv_tbl_1_prio, |
| rmib_apptlv_tbl_1_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[2], |
| rmib_apptlv_tbl_2_prio, |
| rmib_apptlv_tbl_2_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[3], |
| rmib_apptlv_tbl_3_prio, |
| rmib_apptlv_tbl_3_appid); |
| |
| snprintf(pStats->rmib_pgtlv_willing.value.c, 16, "%s", |
| (dcbx_params.remote_ets_willing) ? |
| "willing" : "not willing"); |
| |
| #define RMIB_GET_PG_TLV_BW(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.remote_configuration_bw_percentage[p]) |
| |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_0_bw, 0); |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_1_bw, 1); |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_2_bw, 2); |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_3_bw, 3); |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_4_bw, 4); |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_5_bw, 5); |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_6_bw, 6); |
| RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_7_bw, 7); |
| |
| #define RMIB_GET_PG_TLV_MAP(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.remote_configuration_ets_pg[p]) |
| |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_0_map, 0); |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_1_map, 1); |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_2_map, 2); |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_3_map, 3); |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_4_map, 4); |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_5_map, 5); |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_6_map, 6); |
| RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_7_map, 7); |
| |
| snprintf(pStats->rmib_pgtlv_tc_supported.value.c, 16, "%d", |
| dcbx_params.remote_tc_supported); |
| |
| snprintf(pStats->rmib_pfctlv_willing.value.c, 16, "%s", |
| (dcbx_params.remote_pfc_willing) ? |
| "willing" : "not willing"); |
| |
| snprintf(pStats->rmib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d", |
| (dcbx_params.remote_pfc_bitmap % 2), |
| ((dcbx_params.remote_pfc_bitmap / 2) % 2), |
| ((dcbx_params.remote_pfc_bitmap / 4) % 2), |
| ((dcbx_params.remote_pfc_bitmap / 8) % 2), |
| ((dcbx_params.remote_pfc_bitmap / 16) % 2), |
| ((dcbx_params.remote_pfc_bitmap / 32) % 2), |
| ((dcbx_params.remote_pfc_bitmap / 64) % 2), |
| ((dcbx_params.remote_pfc_bitmap / 128) % 2)); |
| |
| snprintf(pStats->rmib_pfctlv_capable.value.c, 16, "%d", |
| dcbx_params.remote_pfc_cap); |
| |
| /* -------------------- LOCAL MIB -------------------- */ |
| |
| GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[0], |
| lmib_apptlv_tbl_0_prio, |
| lmib_apptlv_tbl_0_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[1], |
| lmib_apptlv_tbl_1_prio, |
| lmib_apptlv_tbl_1_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[2], |
| lmib_apptlv_tbl_2_prio, |
| lmib_apptlv_tbl_2_appid); |
| GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[3], |
| lmib_apptlv_tbl_3_prio, |
| lmib_apptlv_tbl_3_appid); |
| |
| snprintf(pStats->lmib_apptlv_mismatch.value.c, 16, "%s", |
| (dcbx_params.priority_app_mismatch) ? "yes" : "no"); |
| |
| snprintf(pStats->lmib_pgtlv_ets.value.c, 16, "%s", |
| (dcbx_params.local_ets_enable) ? |
| "enabled" : "disabled"); |
| |
| #define LMIB_GET_PG_TLV_BW(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.local_configuration_bw_percentage[p]) |
| |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_0_bw, 0); |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_1_bw, 1); |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_2_bw, 2); |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_3_bw, 3); |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_4_bw, 4); |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_5_bw, 5); |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_6_bw, 6); |
| LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_7_bw, 7); |
| |
| #define LMIB_GET_PG_TLV_MAP(f, p) \ |
| snprintf(pStats->f.value.c, 16, "%d", \ |
| dcbx_params.local_configuration_ets_pg[p]) |
| |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_0_map, 0); |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_1_map, 1); |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_2_map, 2); |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_3_map, 3); |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_4_map, 4); |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_5_map, 5); |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_6_map, 6); |
| LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_7_map, 7); |
| |
| snprintf(pStats->lmib_pgtlv_tc_supported.value.c, 16, "%d", |
| dcbx_params.local_tc_supported); |
| |
| if (dcbx_params.local_pfc_enable) |
| { |
| snprintf(pStats->lmib_pfctlv_pfc.value.c, 16, "enabled"); |
| snprintf(pStats->lmib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d", |
| (dcbx_params.local_pfc_bitmap % 2), |
| ((dcbx_params.local_pfc_bitmap / 2) % 2), |
| ((dcbx_params.local_pfc_bitmap / 4) % 2), |
| ((dcbx_params.local_pfc_bitmap / 8) % 2), |
| ((dcbx_params.local_pfc_bitmap / 16) % 2), |
| ((dcbx_params.local_pfc_bitmap / 32) % 2), |
| ((dcbx_params.local_pfc_bitmap / 64) % 2), |
| ((dcbx_params.local_pfc_bitmap / 128) % 2)); |
| |
| snprintf(pStats->lmib_pfctlv_capable.value.c, 16, "%d", |
| dcbx_params.local_pfc_caps); |
| |
| snprintf(pStats->lmib_pfctlv_mismatch.value.c, 16, "%s", |
| (dcbx_params.pfc_mismatch) ? "yes" : "no"); |
| } |
| else |
| { |
| snprintf(pStats->lmib_pfctlv_pfc.value.c, 16, "disabled"); |
| snprintf(pStats->lmib_pfctlv_pfc_map.value.c, 16, "-"); |
| snprintf(pStats->lmib_pfctlv_capable.value.c, 16, "-"); |
| snprintf(pStats->lmib_pfctlv_mismatch.value.c, 16, "-"); |
| } |
| |
| /* --------------------------------------------------- */ |
| |
| pStats->dcbx_frames_rx.value.ui64 = dcbx_params.dcbx_frames_received; |
| pStats->dcbx_frames_tx.value.ui64 = dcbx_params.dcbx_frames_sent; |
| pStats->pfc_frames_rx.value.ui64 = dcbx_params.pfc_frames_received; |
| pStats->pfc_frames_tx.value.ui64 = dcbx_params.pfc_frames_sent; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatRxRingUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatRxq * pStats = (BnxeKstatRxq *)kstats->ks_data; |
| KstatRingMap * pMap = (KstatRingMap *)kstats->ks_private; |
| um_device_t * pUM = (um_device_t *)pMap->pUM; |
| int idx = pMap->idx; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| lm_tx_chain_t * pTxq = &LM_TXQ(pLM, idx); |
| lm_rx_chain_t * pRxq = &LM_RXQ(pLM, idx); |
| lm_rcq_chain_t * pRcq = &LM_RCQ(pLM, idx); |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| pStats->rxqBdTotal.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].capacity; |
| pStats->rxqBdLeft.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bd_left; |
| pStats->rxqBdPageCnt.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].page_cnt; |
| pStats->rxqBdsPerPage.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bds_per_page; |
| pStats->rxqBdSize.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bd_size; |
| pStats->rxqBdsSkipEop.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bds_skip_eop; |
| pStats->rxqBdProdIdx.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].prod_idx; |
| pStats->rxqBdConsIdx.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].cons_idx; |
| pStats->hwRxqConIdx.value.ui64 = |
| (pRxq->hw_con_idx_ptr != NULL) ? |
| mm_le16_to_cpu(*pRxq->hw_con_idx_ptr) : 0; |
| pStats->sgeBdTotal.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].capacity; |
| pStats->sgeBdLeft.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bd_left; |
| pStats->sgeBdPageCnt.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].page_cnt; |
| pStats->sgeBdsPerPage.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bds_per_page; |
| pStats->sgeBdSize.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bd_size; |
| pStats->sgeBdsSkipEop.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bds_skip_eop; |
| pStats->sgeBdProdIdx.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].prod_idx; |
| pStats->sgeBdConsIdx.value.ui64 = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].cons_idx; |
| pStats->rcqBdTotal.value.ui64 = pRcq->bd_chain.capacity; |
| pStats->rcqBdLeft.value.ui64 = pRcq->bd_chain.bd_left; |
| pStats->rcqBdPageCnt.value.ui64 = pRcq->bd_chain.page_cnt; |
| pStats->rcqBdsPerPage.value.ui64 = pRcq->bd_chain.bds_per_page; |
| pStats->rcqBdSize.value.ui64 = pRcq->bd_chain.bd_size; |
| pStats->rcqBdsSkipEop.value.ui64 = pRcq->bd_chain.bds_skip_eop; |
| pStats->rcqBdProdIdx.value.ui64 = pRcq->bd_chain.prod_idx; |
| pStats->rcqBdConsIdx.value.ui64 = pRcq->bd_chain.cons_idx; |
| pStats->hwRcqConIdx.value.ui64 = |
| (pRcq->hw_con_idx_ptr != NULL) ? |
| mm_le16_to_cpu(*pRcq->hw_con_idx_ptr) : 0; |
| |
| pStats->rxFreeDescs.value.ui64 = s_list_entry_cnt(&LM_RXQ(pLM, idx).common.free_descq); |
| pStats->rxActiveDescs.value.ui64 = s_list_entry_cnt(&LM_RXQ(pLM, idx).active_descq); |
| pStats->rxDoneDescs.value.ui64 = s_list_entry_cnt(&pUM->rxq[idx].doneRxQ); |
| pStats->rxWaitingDescs.value.ui64 = s_list_entry_cnt(&pUM->rxq[idx].waitRxQ); |
| pStats->rxCopied.value.ui64 = pUM->rxq[idx].rxCopied; |
| pStats->rxDiscards.value.ui64 = pUM->rxq[idx].rxDiscards; |
| pStats->rxBufUpInStack.value.ui64 = pUM->rxq[idx].rxBufUpInStack; |
| pStats->rxLowWater.value.ui64 = pUM->rxq[idx].rxLowWater; |
| pStats->inPollMode.value.ui64 = pUM->rxq[idx].inPollMode; |
| pStats->pollCnt.value.ui64 = pUM->rxq[idx].pollCnt; |
| pStats->intrDisableCnt.value.ui64 = pUM->rxq[idx].intrDisableCnt; |
| pStats->intrEnableCnt.value.ui64 = pUM->rxq[idx].intrEnableCnt; |
| pStats->genNumber.value.ui64 = pUM->rxq[idx].genNumber; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| static int BnxeKstatTxRingUpdate(kstat_t * kstats, |
| int rw) |
| { |
| BnxeKstatTxq * pStats = (BnxeKstatTxq *)kstats->ks_data; |
| KstatRingMap * pMap = (KstatRingMap *)kstats->ks_private; |
| um_device_t * pUM = (um_device_t *)pMap->pUM; |
| int idx = pMap->idx; |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| |
| if (rw == KSTAT_WRITE) |
| { |
| return EACCES; |
| } |
| |
| BNXE_LOCK_ENTER_STATS(pUM); |
| |
| pStats->txBdTotal.value.ui64 = LM_TXQ(pLM, idx).bd_chain.capacity; |
| pStats->txBdLeft.value.ui64 = LM_TXQ(pLM, idx).bd_chain.bd_left; |
| pStats->txBdPageCnt.value.ui64 = LM_TXQ(pLM, idx).bd_chain.page_cnt; |
| pStats->txBdsPerPage.value.ui64 = LM_TXQ(pLM, idx).bd_chain.bds_per_page; |
| pStats->txBdSize.value.ui64 = LM_TXQ(pLM, idx).bd_chain.bd_size; |
| pStats->txBdsSkipEop.value.ui64 = LM_TXQ(pLM, idx).bd_chain.bds_skip_eop; |
| pStats->hwTxqConIdx.value.ui64 = |
| (LM_TXQ(pLM, idx).hw_con_idx_ptr != NULL) ? |
| mm_le16_to_cpu(*LM_TXQ(pLM, idx).hw_con_idx_ptr) : 0; |
| pStats->txPktIdx.value.ui64 = LM_TXQ(pLM, idx).pkt_idx; |
| pStats->txBdProdIdx.value.ui64 = LM_TXQ(pLM, idx).bd_chain.prod_idx; |
| pStats->txBdConsIdx.value.ui64 = LM_TXQ(pLM, idx).bd_chain.cons_idx; |
| pStats->txSentPkts.value.ui64 = s_list_entry_cnt(&pUM->txq[idx].sentTxQ); |
| pStats->txFreeDesc.value.ui64 = s_list_entry_cnt(&pUM->txq[idx].freeTxDescQ); |
| pStats->txWaitingPkts.value.ui64 = s_list_entry_cnt(&pUM->txq[idx].waitTxDescQ); |
| pStats->txLowWater.value.ui64 = pUM->txq[idx].txLowWater; |
| pStats->txFailed.value.ui64 = pUM->txq[idx].txFailed; |
| pStats->txDiscards.value.ui64 = pUM->txq[idx].txDiscards; |
| pStats->txRecycle.value.ui64 = pUM->txq[idx].txRecycle; |
| pStats->txCopied.value.ui64 = pUM->txq[idx].txCopied; |
| pStats->txBlocked.value.ui64 = pUM->txq[idx].txBlocked; |
| pStats->txWait.value.ui64 = pUM->txq[idx].txWait; |
| |
| BNXE_LOCK_EXIT_STATS(pUM); |
| |
| return 0; |
| } |
| |
| |
| boolean_t BnxeKstatInitRxQ(um_device_t * pUM, |
| int idx) |
| { |
| char buf[32]; |
| |
| BnxeKstatRxq * pStatsRxq; |
| #define BNXE_KSTAT_RXQ(f, t) kstat_named_init(&pStatsRxq->f, #f, t) |
| |
| snprintf(buf, sizeof(buf), "rxq%d", idx); |
| |
| if ((pUM->kstats_rxq[idx] = kstat_create("bnxe", |
| pUM->instance, |
| buf, |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_RXQ_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create rxq%d kstat", idx); |
| return B_FALSE; |
| } |
| |
| pStatsRxq = (BnxeKstatRxq *)pUM->kstats_rxq[idx]->ks_data; |
| |
| BNXE_KSTAT_RXQ(rxqBdTotal, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxqBdLeft, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxqBdPageCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxqBdsPerPage, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxqBdSize, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxqBdsSkipEop, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxqBdProdIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxqBdConsIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(hwRxqConIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdTotal, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdLeft, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdPageCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdsPerPage, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdSize, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdsSkipEop, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdProdIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(sgeBdConsIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdTotal, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdLeft, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdPageCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdsPerPage, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdSize, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdsSkipEop, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdProdIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rcqBdConsIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(hwRcqConIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxFreeDescs, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxActiveDescs, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxDoneDescs, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxWaitingDescs, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxCopied, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxBufUpInStack, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(rxLowWater, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(inPollMode, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(pollCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(intrDisableCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(intrEnableCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_RXQ(genNumber, KSTAT_DATA_UINT64); |
| |
| pUM->kstats_rxq_map[idx].idx = idx; |
| pUM->kstats_rxq_map[idx].pUM = pUM; |
| |
| pUM->kstats_rxq[idx]->ks_update = BnxeKstatRxRingUpdate; |
| pUM->kstats_rxq[idx]->ks_private = (void *)&pUM->kstats_rxq_map[idx]; |
| |
| kstat_install(pUM->kstats_rxq[idx]); |
| |
| return B_TRUE; |
| } |
| |
| |
| boolean_t BnxeKstatInitTxQ(um_device_t * pUM, |
| int idx) |
| { |
| char buf[32]; |
| |
| BnxeKstatTxq * pStatsTxq; |
| #define BNXE_KSTAT_TXQ(f, t) kstat_named_init(&pStatsTxq->f, #f, t) |
| |
| snprintf(buf, sizeof(buf), "txq%d", idx); |
| |
| if ((pUM->kstats_txq[idx] = kstat_create("bnxe", |
| pUM->instance, |
| buf, |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_TXQ_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create txq%d kstat", idx); |
| return B_FALSE; |
| } |
| |
| pStatsTxq = (BnxeKstatTxq *)pUM->kstats_txq[idx]->ks_data; |
| |
| BNXE_KSTAT_TXQ(txBdTotal, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBdLeft, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBdPageCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBdsPerPage, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBdSize, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBdsSkipEop, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(hwTxqConIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txPktIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBdProdIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBdConsIdx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txSentPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txFreeDesc, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txWaitingPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txLowWater, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txFailed, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txRecycle, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txCopied, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txBlocked, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_TXQ(txWait, KSTAT_DATA_UINT64); |
| |
| pUM->kstats_txq_map[idx].idx = idx; |
| pUM->kstats_txq_map[idx].pUM = pUM; |
| |
| pUM->kstats_txq[idx]->ks_update = BnxeKstatTxRingUpdate; |
| pUM->kstats_txq[idx]->ks_private = (void *)&pUM->kstats_txq_map[idx]; |
| |
| kstat_install(pUM->kstats_txq[idx]); |
| |
| return B_TRUE; |
| } |
| |
| |
| boolean_t BnxeKstatInit(um_device_t * pUM) |
| { |
| lm_device_t * pLM = (lm_device_t *)pUM; |
| char buf[32]; |
| int idx; |
| |
| BnxeKstat * pStats; |
| BnxeKstatLink * pStatsLink; |
| BnxeKstatIntr * pStatsIntr; |
| BnxeKstatL2Chip * pStatsL2Chip; |
| BnxeKstatL2Driver * pStatsL2Driver; |
| BnxeKstatEthStats * pStatsL2Stats; |
| BnxeKstatFcoe * pStatsFcoe; |
| BnxeKstatDcbx * pStatsDcbx; |
| #define BNXE_KSTAT(f, t) kstat_named_init(&pStats->f, #f, t) |
| #define BNXE_KSTAT_LINK(f, t) kstat_named_init(&pStatsLink->f, #f, t) |
| #define BNXE_KSTAT_INTR(f, t) kstat_named_init(&pStatsIntr->f, #f, t) |
| #define BNXE_KSTAT_L2_CHIP(f, t) kstat_named_init(&pStatsL2Chip->f, #f, t) |
| #define BNXE_KSTAT_L2_DRIVER(f, t) kstat_named_init(&pStatsL2Driver->f, #f, t) |
| #define BNXE_KSTAT_L2_STATS(f, t) kstat_named_init(&pStatsL2Stats->f, #f, t) |
| #define BNXE_KSTAT_FCOE(f, t) kstat_named_init(&pStatsFcoe->f, #f, t) |
| #define BNXE_KSTAT_DCBX(f, t) kstat_named_init(&pStatsDcbx->f, #f, t) |
| |
| /****************************************************************/ |
| |
| if ((pUM->kstats = kstat_create("bnxe", |
| pUM->instance, |
| "stats", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create kstat"); |
| return B_FALSE; |
| } |
| |
| pStats = (BnxeKstat *)pUM->kstats->ks_data; |
| |
| BNXE_KSTAT(umdev_hi, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(umdev_lo, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(version, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(versionFW, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(versionBC, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(chipName, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(chipID, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(devBDF, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(devID, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(multiFunction, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(multiFunctionVnics, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(macAddr, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(hwInitDone, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(clientsHw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(clientsDevi, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(clientsBound, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(txMsgPullUp, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(intrAlloc, KSTAT_DATA_CHAR); |
| BNXE_KSTAT(intrFired, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(timerFired, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(timerReply, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(timerNoReplyTotal, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(timerNoReplyCurrent, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(timerDone, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workQueueInstCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemInstQueued, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemInstError, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemInstComplete, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemInstHighWater, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workQueueDelayCnt, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemDelayQueued, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemDelayError, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemDelayComplete, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(workItemDelayHighWater, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(memAllocBlocks, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(memAllocDMAs, KSTAT_DATA_UINT64); |
| BNXE_KSTAT(memAllocBARs, KSTAT_DATA_UINT64); |
| |
| pUM->kstats->ks_update = BnxeKstatUpdate; |
| pUM->kstats->ks_private = (void *)pUM; |
| |
| kstat_install(pUM->kstats); |
| |
| /****************************************************************/ |
| |
| if ((pUM->kstatsLink = kstat_create("bnxe", |
| pUM->instance, |
| "link", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_LINK_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create link kstat"); |
| return B_FALSE; |
| } |
| |
| pStatsLink = (BnxeKstatLink *)pUM->kstatsLink->ks_data; |
| |
| BNXE_KSTAT_LINK(clients, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_LINK(uptime, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_LINK(mtuL2, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_LINK(mtuFCOE, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_LINK(speed, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_LINK(link, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_LINK(duplex, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_LINK(pauseRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_LINK(pauseTx, KSTAT_DATA_UINT64); |
| |
| pUM->kstatsLink->ks_update = BnxeKstatLinkUpdate; |
| pUM->kstatsLink->ks_private = (void *)pUM; |
| |
| kstat_install(pUM->kstatsLink); |
| |
| /****************************************************************/ |
| |
| if ((pUM->kstatsIntr = kstat_create("bnxe", |
| pUM->instance, |
| "intr", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_INTR_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create intr kstat"); |
| return B_FALSE; |
| } |
| |
| pStatsIntr = (BnxeKstatIntr *)pUM->kstatsIntr->ks_data; |
| |
| BNXE_KSTAT_INTR(intrAlloc, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_INTR(intrFired, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(intrWrongState, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(intrInDisabled, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(intrZeroStatus, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_00, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_01, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_02, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_03, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_04, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_05, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_06, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_07, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_08, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_09, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_10, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_11, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_12, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_13, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_14, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_15, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_16, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_00, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_01, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_02, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_03, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_04, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_05, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_06, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_07, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_08, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_09, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_10, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_11, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_12, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_13, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_14, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_15, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_nc_16, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_00, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_01, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_02, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_03, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_04, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_05, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_06, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_07, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_08, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_09, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_10, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_11, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_12, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_13, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_14, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_15, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_16, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_00, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_01, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_02, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_03, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_04, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_05, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_06, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_07, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_08, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_09, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_10, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_11, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_12, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_13, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_14, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_15, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_INTR(sb_poll_nc_16, KSTAT_DATA_UINT64); |
| |
| pUM->kstatsIntr->ks_update = BnxeKstatIntrUpdate; |
| pUM->kstatsIntr->ks_private = (void *)pUM; |
| |
| kstat_install(pUM->kstatsIntr); |
| |
| /****************************************************************/ |
| |
| if ((pUM->kstatsL2Chip = kstat_create("bnxe", |
| pUM->instance, |
| "l2chip", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_L2_CHIP_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create l2chip kstat"); |
| return B_FALSE; |
| } |
| |
| pStatsL2Chip = (BnxeKstatL2Chip *)pUM->kstatsL2Chip->ks_data; |
| |
| BNXE_KSTAT_L2_CHIP(IfHCInOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInBadOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutBadOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInUcastPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInMulticastPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInBroadcastPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutUcastPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutMulticastPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutBroadcastPkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInUcastOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInMulticastOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInBroadcastOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutUcastOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutMulticastOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutBroadcastOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCOutDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfHCInFalseCarrierErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsInternalMacTransmitErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsCarrierSenseErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsFCSErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsAlignmentErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsSingleCollisionFrames, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsMultipleCollisionFrames, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsDeferredTransmissions, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsExcessiveCollisions, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(Dot3StatsLateCollisions, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsCollisions, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsFragments, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsJabbers, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsUndersizePkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsOverrsizePkts, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsTx64Octets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsTx65to127Octets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsTx128to255Octets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsTx256to511Octets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsTx512to1023Octets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsTx1024to1522Octets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(EtherStatsTxOver1522Octets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(XonPauseFramesReceived, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(XoffPauseFramesReceived, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(OutXonSent, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(OutXoffSent, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(FlowControlDone, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(MacControlFramesReceived, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(XoffStateEntered, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfInFramesL2FilterDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfInTTL0Discards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfInxxOverflowDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfInMBUFDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfInErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfInErrorsOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(IfInNoBrbBuffer, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigBrbPacket, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigBrbTruncate, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigFlowCtrlDiscard, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigFlowCtrlOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigFlowCtrlPacket, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigMngDiscard, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigMngOctetInp, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigMngOctetOut, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigMngPacketInp, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigMngPacketOut, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigPbfOctets, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigPbfPacket, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_CHIP(NigSafcInp, KSTAT_DATA_UINT64); |
| |
| pUM->kstatsL2Chip->ks_update = BnxeKstatL2ChipUpdate; |
| pUM->kstatsL2Chip->ks_private = (void *)pUM; |
| |
| kstat_install(pUM->kstatsL2Chip); |
| |
| /****************************************************************/ |
| |
| if ((pUM->kstatsL2Driver = kstat_create("bnxe", |
| pUM->instance, |
| "l2driver", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_L2_DRIVER_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create l2driver kstat"); |
| return B_FALSE; |
| } |
| |
| pStatsL2Driver = (BnxeKstatL2Driver *)pUM->kstatsL2Driver->ks_data; |
| |
| BNXE_KSTAT_L2_DRIVER(RxIPv4FragCount, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(RxIpCsErrorCount, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(RxTcpCsErrorCount, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(RxLlcSnapCount, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(RxPhyErrorCount, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(RxIpv6ExtCount, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(TxNoL2Bd, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(TxNoSqWqe, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_DRIVER(TxL2AssemblyBufUse, KSTAT_DATA_UINT64); |
| |
| pUM->kstatsL2Driver->ks_update = BnxeKstatL2DriverUpdate; |
| pUM->kstatsL2Driver->ks_private = (void *)pUM; |
| |
| kstat_install(pUM->kstatsL2Driver); |
| |
| /****************************************************************/ |
| |
| if ((pUM->kstatsL2Stats = kstat_create("bnxe", |
| pUM->instance, |
| "l2stats", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_ETH_STATS_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create l2stats kstat"); |
| return B_FALSE; |
| } |
| |
| pStatsL2Stats = (BnxeKstatEthStats *)pUM->kstatsL2Stats->ks_data; |
| |
| BNXE_KSTAT_L2_STATS(txFramesOk, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxFramesOk, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxCrcErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(alignErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(collisionsSingle, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(collisionsMultiple, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(framesDeferred, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(collisonsMax, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxOverrun, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txOverrun, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txFramesUnicast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txFramesMulticast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txFramesBroadcast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxFramesUnicast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxFramesMulticast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxFramesBroadcast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxNoBufferDrop, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxBytes, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txBytes, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(offloadIP4, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(offloadTCP, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(ifInDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(ifInErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(ifOutErrors, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(offloadIP6, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(offloadTCP6, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txDiscards, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxBytesUnicast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxBytesMulticast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(rxBytesBroadcast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txBytesUnicast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txBytesMulticast, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_L2_STATS(txBytesBroadcast, KSTAT_DATA_UINT64); |
| |
| pUM->kstatsL2Stats->ks_update = BnxeKstatL2StatsUpdate; |
| pUM->kstatsL2Stats->ks_private = (void *)pUM; |
| |
| kstat_install(pUM->kstatsL2Stats); |
| |
| /****************************************************************/ |
| |
| if (BNXE_FCOE(pUM)) |
| { |
| if ((pUM->kstatsFcoe = kstat_create("bnxe", |
| pUM->instance, |
| "fcoe", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_FCOE_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create fcoe kstat"); |
| BnxeKstatFini(pUM); |
| return B_FALSE; |
| } |
| |
| pStatsFcoe = (BnxeKstatFcoe *)pUM->kstatsFcoe->ks_data; |
| |
| BNXE_KSTAT_FCOE(pdev_hi, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_FCOE(pdev_lo, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_FCOE(instance, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_FCOE(macAddr, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_FCOE(pwwn_hi, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_FCOE(pwwn_lo, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_FCOE(mtu, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(initWqeTx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(initWqeTxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(initCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(initCqeRxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(offloadConnWqeTx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(offloadConnWqeTxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(offloadConnCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(offloadConnCqeRxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(enableConnWqeTx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(enableConnWqeTxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(enableConnCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(enableConnCqeRxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(disableConnWqeTx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(disableConnWqeTxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(disableConnCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(disableConnCqeRxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyConnWqeTx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyConnWqeTxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyConnCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyConnCqeRxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyWqeTx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyWqeTxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(destroyCqeRxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(compRequestCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(compRequestCqeRxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(statWqeTx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(statWqeTxErr, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(statCqeRx, KSTAT_DATA_UINT64); |
| BNXE_KSTAT_FCOE(statCqeRxErr, KSTAT_DATA_UINT64); |
| |
| pUM->kstatsFcoe->ks_update = BnxeKstatFcoeUpdate; |
| pUM->kstatsFcoe->ks_private = (void *)pUM; |
| |
| kstat_install(pUM->kstatsFcoe); |
| |
| if (!BnxeKstatInitRxQ(pUM, FCOE_CID(pLM))) |
| { |
| BnxeKstatFini(pUM); |
| return B_FALSE; |
| } |
| |
| if (!BnxeKstatInitTxQ(pUM, FCOE_CID(pLM))) |
| { |
| BnxeKstatFini(pUM); |
| return B_FALSE; |
| } |
| } |
| |
| /****************************************************************/ |
| |
| if (IS_DCB_SUPPORTED(pLM)) |
| { |
| if ((pUM->kstatsDcbx = kstat_create("bnxe", |
| pUM->instance, |
| "dcbx", |
| "net", |
| KSTAT_TYPE_NAMED, |
| BNXE_KSTAT_DCBX_SIZE, |
| 0)) == NULL) |
| { |
| BnxeLogWarn(pUM, "Failed to create dcbx kstat"); |
| BnxeKstatFini(pUM); |
| return B_FALSE; |
| } |
| |
| pStatsDcbx = (BnxeKstatDcbx *)pUM->kstatsDcbx->ks_data; |
| |
| BNXE_KSTAT_DCBX(dcbx_sync, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(dcbx_vers, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(overwrite_settings, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(prio_tag, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(prio_tag_fcoe, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(prio_tag_iscsi, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(prio_tag_net, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_0, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_1, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_2, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_3, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_4, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_5, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_6, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(pfc_prio_7, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_0_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_1_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_2_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_3_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_4_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_5_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_6_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_prio_7_pg, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_0_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_1_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_2_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_3_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_4_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_5_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_6_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(ets_pg_7_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(lldp, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(lldp_tx_interval, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(lldp_tx_fast_interval, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_willing, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tx, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_net_prio, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_0_prio, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_0_appid, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_1_prio, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_1_appid, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_2_prio, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_2_appid, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_3_prio, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_apptlv_tbl_3_appid, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_willing, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_tx, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_tc_supported, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_ets, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_0_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_1_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_2_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_3_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_4_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_5_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_6_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_pg_7_bw, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_prio_0_map, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_prio_1_map, KSTAT_DATA_CHAR); |
| BNXE_KSTAT_DCBX(amib_pgtlv_prio_2_map, KSTAT_DATA_CHAR); |
|