/* * 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 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include #include #define RDC_NAME_FORMAT1 "RDC_" #define TDC_NAME_FORMAT1 "TDC_" #define CH_NAME_FORMAT "%d" static int hxge_mmac_stat_update(kstat_t *ksp, int rw); void hxge_init_statsp(p_hxge_t hxgep) { size_t stats_size; HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_init_statsp")); stats_size = sizeof (hxge_stats_t); hxgep->statsp = KMEM_ZALLOC(stats_size, KM_SLEEP); hxgep->statsp->stats_size = stats_size; HXGE_DEBUG_MSG((hxgep, KST_CTL, " <== hxge_init_statsp")); } typedef struct { uint8_t index; uint8_t type; char *name; } hxge_kstat_index_t; typedef enum { RDC_STAT_PACKETS = 0, RDC_STAT_BYTES, RDC_STAT_ERRORS, RDC_STAT_JUMBO_PKTS, RDC_STAT_RCR_UNKNOWN_ERR, RDC_STAT_RCR_SHA_PAR_ERR, RDC_STAT_RBR_PRE_PAR_ERR, RDC_STAT_RBR_PRE_EMTY, RDC_STAT_RCR_SHADOW_FULL, RDC_STAT_RBR_TMOUT, RDC_STAT_PEU_RESP_ERR, RDC_STAT_CTRL_FIFO_ECC_ERR, RDC_STAT_DATA_FIFO_ECC_ERR, RDC_STAT_RCRFULL, RDC_STAT_RBR_EMPTY, RDC_STAT_RBR_EMPTY_FAIL, RDC_STAT_RBR_EMPTY_RESTORE, RDC_STAT_RBR_FULL, RDC_STAT_RCR_INVALIDS, RDC_STAT_RCRTO, RDC_STAT_RCRTHRES, RDC_STAT_PKT_DROP, RDC_STAT_END } hxge_rdc_stat_index_t; hxge_kstat_index_t hxge_rdc_stats[] = { {RDC_STAT_PACKETS, KSTAT_DATA_UINT64, "rdc_packets"}, {RDC_STAT_BYTES, KSTAT_DATA_UINT64, "rdc_bytes"}, {RDC_STAT_ERRORS, KSTAT_DATA_ULONG, "rdc_errors"}, {RDC_STAT_JUMBO_PKTS, KSTAT_DATA_ULONG, "rdc_jumbo_pkts"}, {RDC_STAT_RCR_UNKNOWN_ERR, KSTAT_DATA_ULONG, "rdc_rcr_unknown_err"}, {RDC_STAT_RCR_SHA_PAR_ERR, KSTAT_DATA_ULONG, "rdc_rcr_sha_par_err"}, {RDC_STAT_RBR_PRE_PAR_ERR, KSTAT_DATA_ULONG, "rdc_rbr_pre_par_err"}, {RDC_STAT_RBR_PRE_EMTY, KSTAT_DATA_ULONG, "rdc_rbr_pre_empty"}, {RDC_STAT_RCR_SHADOW_FULL, KSTAT_DATA_ULONG, "rdc_rcr_shadow_full"}, {RDC_STAT_RBR_TMOUT, KSTAT_DATA_ULONG, "rdc_rbr_tmout"}, {RDC_STAT_PEU_RESP_ERR, KSTAT_DATA_ULONG, "peu_resp_err"}, {RDC_STAT_CTRL_FIFO_ECC_ERR, KSTAT_DATA_ULONG, "ctrl_fifo_ecc_err"}, {RDC_STAT_DATA_FIFO_ECC_ERR, KSTAT_DATA_ULONG, "data_fifo_ecc_err"}, {RDC_STAT_RCRFULL, KSTAT_DATA_ULONG, "rdc_rcrfull"}, {RDC_STAT_RBR_EMPTY, KSTAT_DATA_ULONG, "rdc_rbr_empty"}, {RDC_STAT_RBR_EMPTY_FAIL, KSTAT_DATA_ULONG, "rdc_rbr_empty_fail"}, {RDC_STAT_RBR_EMPTY_FAIL, KSTAT_DATA_ULONG, "rdc_rbr_empty_restore"}, {RDC_STAT_RBR_FULL, KSTAT_DATA_ULONG, "rdc_rbrfull"}, {RDC_STAT_RCR_INVALIDS, KSTAT_DATA_ULONG, "rdc_rcr_invalids"}, {RDC_STAT_RCRTO, KSTAT_DATA_ULONG, "rdc_rcrto"}, {RDC_STAT_RCRTHRES, KSTAT_DATA_ULONG, "rdc_rcrthres"}, {RDC_STAT_PKT_DROP, KSTAT_DATA_ULONG, "rdc_pkt_drop"}, {RDC_STAT_END, KSTAT_DATA_ULONG, NULL} }; typedef enum { RDC_SYS_STAT_CTRL_FIFO_SEC = 0, RDC_SYS_STAT_CTRL_FIFO_DED, RDC_SYS_STAT_DATA_FIFO_SEC, RDC_SYS_STAT_DATA_FIFO_DED, RDC_SYS_STAT_END } hxge_rdc_sys_stat_idx_t; hxge_kstat_index_t hxge_rdc_sys_stats[] = { {RDC_SYS_STAT_CTRL_FIFO_SEC, KSTAT_DATA_UINT64, "rdc_ctrl_fifo_sec"}, {RDC_SYS_STAT_CTRL_FIFO_DED, KSTAT_DATA_UINT64, "rdc_ctrl_fifo_ded"}, {RDC_SYS_STAT_DATA_FIFO_SEC, KSTAT_DATA_UINT64, "rdc_data_fifo_sec"}, {RDC_SYS_STAT_DATA_FIFO_DED, KSTAT_DATA_UINT64, "tdc_data_fifo_ded"}, {RDC_SYS_STAT_END, KSTAT_DATA_UINT64, NULL} }; typedef enum { TDC_STAT_PACKETS = 0, TDC_STAT_BYTES, TDC_STAT_BYTES_WITH_PAD, TDC_STAT_ERRORS, TDC_STAT_TX_INITS, TDC_STAT_TX_NO_BUF, TDC_STAT_PEU_RESP_ERR, TDC_STAT_PKT_SIZE_ERR, TDC_STAT_TX_RNG_OFLOW, TDC_STAT_PKT_SIZE_HDR_ERR, TDC_STAT_RUNT_PKT_DROP_ERR, TDC_STAT_PREF_PAR_ERR, TDC_STAT_TDR_PREF_CPL_TO, TDC_STAT_PKT_CPL_TO, TDC_STAT_INVALID_SOP, TDC_STAT_UNEXPECTED_SOP, TDC_STAT_COUNT_HDR_SIZE_ERR, TDC_STAT_COUNT_RUNT, TDC_STAT_COUNT_ABORT, TDC_STAT_TX_STARTS, TDC_STAT_TX_NO_DESC, TDC_STAT_TX_DMA_BIND_FAIL, TDC_STAT_TX_HDR_PKTS, TDC_STAT_TX_DDI_PKTS, TDC_STAT_TX_JUMBO_PKTS, TDC_STAT_TX_MAX_PEND, TDC_STAT_TX_MARKS, TDC_STAT_END } hxge_tdc_stats_index_t; hxge_kstat_index_t hxge_tdc_stats[] = { {TDC_STAT_PACKETS, KSTAT_DATA_UINT64, "tdc_packets"}, {TDC_STAT_BYTES, KSTAT_DATA_UINT64, "tdc_bytes"}, {TDC_STAT_BYTES_WITH_PAD, KSTAT_DATA_UINT64, "tdc_bytes_with_pad"}, {TDC_STAT_ERRORS, KSTAT_DATA_UINT64, "tdc_errors"}, {TDC_STAT_TX_INITS, KSTAT_DATA_ULONG, "tdc_tx_inits"}, {TDC_STAT_TX_NO_BUF, KSTAT_DATA_ULONG, "tdc_tx_no_buf"}, {TDC_STAT_PEU_RESP_ERR, KSTAT_DATA_ULONG, "tdc_peu_resp_err"}, {TDC_STAT_PKT_SIZE_ERR, KSTAT_DATA_ULONG, "tdc_pkt_size_err"}, {TDC_STAT_TX_RNG_OFLOW, KSTAT_DATA_ULONG, "tdc_tx_rng_oflow"}, {TDC_STAT_PKT_SIZE_HDR_ERR, KSTAT_DATA_ULONG, "tdc_pkt_size_hdr_err"}, {TDC_STAT_RUNT_PKT_DROP_ERR, KSTAT_DATA_ULONG, "tdc_runt_pkt_drop_err"}, {TDC_STAT_PREF_PAR_ERR, KSTAT_DATA_ULONG, "tdc_pref_par_err"}, {TDC_STAT_TDR_PREF_CPL_TO, KSTAT_DATA_ULONG, "tdc_tdr_pref_cpl_to"}, {TDC_STAT_PKT_CPL_TO, KSTAT_DATA_ULONG, "tdc_pkt_cpl_to"}, {TDC_STAT_INVALID_SOP, KSTAT_DATA_ULONG, "tdc_invalid_sop"}, {TDC_STAT_UNEXPECTED_SOP, KSTAT_DATA_ULONG, "tdc_unexpected_sop"}, {TDC_STAT_COUNT_HDR_SIZE_ERR, KSTAT_DATA_ULONG, "tdc_count_hdr_size_err"}, {TDC_STAT_COUNT_RUNT, KSTAT_DATA_ULONG, "tdc_count_runt"}, {TDC_STAT_COUNT_ABORT, KSTAT_DATA_ULONG, "tdc_count_abort"}, {TDC_STAT_TX_STARTS, KSTAT_DATA_ULONG, "tdc_tx_starts"}, {TDC_STAT_TX_NO_DESC, KSTAT_DATA_ULONG, "tdc_tx_no_desc"}, {TDC_STAT_TX_DMA_BIND_FAIL, KSTAT_DATA_ULONG, "tdc_tx_dma_bind_fail"}, {TDC_STAT_TX_HDR_PKTS, KSTAT_DATA_ULONG, "tdc_tx_hdr_pkts"}, {TDC_STAT_TX_DDI_PKTS, KSTAT_DATA_ULONG, "tdc_tx_ddi_pkts"}, {TDC_STAT_TX_JUMBO_PKTS, KSTAT_DATA_ULONG, "tdc_tx_jumbo_pkts"}, {TDC_STAT_TX_MAX_PEND, KSTAT_DATA_ULONG, "tdc_tx_max_pend"}, {TDC_STAT_TX_MARKS, KSTAT_DATA_ULONG, "tdc_tx_marks"}, {TDC_STAT_END, KSTAT_DATA_ULONG, NULL} }; typedef enum { REORD_TBL_PAR_ERR = 0, REORD_BUF_DED_ERR, REORD_BUF_SEC_ERR, TDC_SYS_STAT_END } hxge_tdc_sys_stat_idx_t; hxge_kstat_index_t hxge_tdc_sys_stats[] = { {REORD_TBL_PAR_ERR, KSTAT_DATA_UINT64, "reord_tbl_par_err"}, {REORD_BUF_DED_ERR, KSTAT_DATA_UINT64, "reord_buf_ded_err"}, {REORD_BUF_SEC_ERR, KSTAT_DATA_UINT64, "reord_buf_sec_err"}, {TDC_SYS_STAT_END, KSTAT_DATA_UINT64, NULL} }; typedef enum { VMAC_STAT_TX_FRAME_CNT, /* vmac_tx_frame_cnt_t */ VMAC_STAT_TX_BYTE_CNT, /* vmac_tx_byte_cnt_t */ VMAC_STAT_RX_FRAME_CNT, /* vmac_rx_frame_cnt_t */ VMAC_STAT_RX_BYTE_CNT, /* vmac_rx_byte_cnt_t */ VMAC_STAT_RX_DROP_FRAME_CNT, /* vmac_rx_drop_fr_cnt_t */ VMAC_STAT_RX_DROP_BYTE_CNT, /* vmac_rx_drop_byte_cnt_t */ VMAC_STAT_RX_CRC_CNT, /* vmac_rx_crc_cnt_t */ VMAC_STAT_RX_PAUSE_CNT, /* vmac_rx_pause_cnt_t */ VMAC_STAT_RX_BCAST_FR_CNT, /* vmac_rx_bcast_fr_cnt_t */ VMAC_STAT_RX_MCAST_FR_CNT, /* vmac_rx_mcast_fr_cnt_t */ VMAC_STAT_END } hxge_vmac_stat_index_t; hxge_kstat_index_t hxge_vmac_stats[] = { {VMAC_STAT_TX_FRAME_CNT, KSTAT_DATA_UINT64, "vmac_tx_frame_cnt"}, {VMAC_STAT_TX_BYTE_CNT, KSTAT_DATA_UINT64, "vmac_tx_byte_cnt"}, {VMAC_STAT_RX_FRAME_CNT, KSTAT_DATA_UINT64, "vmac_rx_frame_cnt"}, {VMAC_STAT_RX_BYTE_CNT, KSTAT_DATA_UINT64, "vmac_rx_byte_cnt"}, {VMAC_STAT_RX_DROP_FRAME_CNT, KSTAT_DATA_UINT64, "vmac_rx_drop_frame_cnt"}, {VMAC_STAT_RX_DROP_BYTE_CNT, KSTAT_DATA_UINT64, "vmac_rx_drop_byte_cnt"}, {VMAC_STAT_RX_CRC_CNT, KSTAT_DATA_UINT64, "vmac_rx_crc_cnt"}, {VMAC_STAT_RX_PAUSE_CNT, KSTAT_DATA_UINT64, "vmac_rx_pause_cnt"}, {VMAC_STAT_RX_BCAST_FR_CNT, KSTAT_DATA_UINT64, "vmac_rx_bcast_fr_cnt"}, {VMAC_STAT_RX_MCAST_FR_CNT, KSTAT_DATA_UINT64, "vmac_rx_mcast_fr_cnt"}, {VMAC_STAT_END, KSTAT_DATA_UINT64, NULL} }; typedef enum { PFC_STAT_PKT_DROP, PFC_STAT_TCAM_PARITY_ERR, PFC_STAT_VLAN_PARITY_ERR, PFC_STAT_BAD_CS_COUNT, PFC_STAT_DROP_COUNT, PFC_STAT_TCP_CTRL_DROP, PFC_STAT_L2_ADDR_DROP, PFC_STAT_CLASS_CODE_DROP, PFC_STAT_TCAM_DROP, PFC_STAT_VLAN_DROP, PFC_STAT_END } hxge_pfc_stat_index_t; hxge_kstat_index_t hxge_pfc_stats[] = { {PFC_STAT_PKT_DROP, KSTAT_DATA_ULONG, "pfc_pkt_drop"}, {PFC_STAT_TCAM_PARITY_ERR, KSTAT_DATA_ULONG, "pfc_tcam_parity_err"}, {PFC_STAT_VLAN_PARITY_ERR, KSTAT_DATA_ULONG, "pfc_vlan_parity_err"}, {PFC_STAT_BAD_CS_COUNT, KSTAT_DATA_ULONG, "pfc_bad_cs_count"}, {PFC_STAT_DROP_COUNT, KSTAT_DATA_ULONG, "pfc_drop_count"}, {PFC_STAT_TCP_CTRL_DROP, KSTAT_DATA_ULONG, " pfc_pkt_drop_tcp_ctrl"}, {PFC_STAT_L2_ADDR_DROP, KSTAT_DATA_ULONG, " pfc_pkt_drop_l2_addr"}, {PFC_STAT_CLASS_CODE_DROP, KSTAT_DATA_ULONG, " pfc_pkt_drop_class_code"}, {PFC_STAT_TCAM_DROP, KSTAT_DATA_ULONG, " pfc_pkt_drop_tcam"}, {PFC_STAT_VLAN_DROP, KSTAT_DATA_ULONG, " pfc_pkt_drop_vlan"}, {PFC_STAT_END, KSTAT_DATA_ULONG, NULL} }; typedef enum { SPC_ACC_ERR = 0, TDC_PIOACC_ERR, RDC_PIOACC_ERR, PFC_PIOACC_ERR, VMAC_PIOACC_ERR, CPL_HDRQ_PARERR, CPL_DATAQ_PARERR, RETRYRAM_XDLH_PARERR, RETRYSOTRAM_XDLH_PARERR, P_HDRQ_PARERR, P_DATAQ_PARERR, NP_HDRQ_PARERR, NP_DATAQ_PARERR, EIC_MSIX_PARERR, HCR_PARERR, PEU_SYS_STAT_END } hxge_peu_sys_stat_idx_t; hxge_kstat_index_t hxge_peu_sys_stats[] = { {SPC_ACC_ERR, KSTAT_DATA_UINT64, "spc_acc_err"}, {TDC_PIOACC_ERR, KSTAT_DATA_UINT64, "tdc_pioacc_err"}, {RDC_PIOACC_ERR, KSTAT_DATA_UINT64, "rdc_pioacc_err"}, {PFC_PIOACC_ERR, KSTAT_DATA_UINT64, "pfc_pioacc_err"}, {VMAC_PIOACC_ERR, KSTAT_DATA_UINT64, "vmac_pioacc_err"}, {CPL_HDRQ_PARERR, KSTAT_DATA_UINT64, "cpl_hdrq_parerr"}, {CPL_DATAQ_PARERR, KSTAT_DATA_UINT64, "cpl_dataq_parerr"}, {RETRYRAM_XDLH_PARERR, KSTAT_DATA_UINT64, "retryram_xdlh_parerr"}, {RETRYSOTRAM_XDLH_PARERR, KSTAT_DATA_UINT64, "retrysotram_xdlh_parerr"}, {P_HDRQ_PARERR, KSTAT_DATA_UINT64, "p_hdrq_parerr"}, {P_DATAQ_PARERR, KSTAT_DATA_UINT64, "p_dataq_parerr"}, {NP_HDRQ_PARERR, KSTAT_DATA_UINT64, "np_hdrq_parerr"}, {NP_DATAQ_PARERR, KSTAT_DATA_UINT64, "np_dataq_parerr"}, {EIC_MSIX_PARERR, KSTAT_DATA_UINT64, "eic_msix_parerr"}, {HCR_PARERR, KSTAT_DATA_UINT64, "hcr_parerr"}, {TDC_SYS_STAT_END, KSTAT_DATA_UINT64, NULL} }; typedef enum { MMAC_MAX_ADDR, MMAC_AVAIL_ADDR, MMAC_ADDR_POOL1, MMAC_ADDR_POOL2, MMAC_ADDR_POOL3, MMAC_ADDR_POOL4, MMAC_ADDR_POOL5, MMAC_ADDR_POOL6, MMAC_ADDR_POOL7, MMAC_ADDR_POOL8, MMAC_ADDR_POOL9, MMAC_ADDR_POOL10, MMAC_ADDR_POOL11, MMAC_ADDR_POOL12, MMAC_ADDR_POOL13, MMAC_ADDR_POOL14, MMAC_ADDR_POOL15, MMAC_ADDR_POOL16, MMAC_STATS_END } hxge_mmac_stat_index_t; hxge_kstat_index_t hxge_mmac_stats[] = { {MMAC_MAX_ADDR, KSTAT_DATA_UINT64, "max_mmac_addr"}, {MMAC_AVAIL_ADDR, KSTAT_DATA_UINT64, "avail_mmac_addr"}, {MMAC_ADDR_POOL1, KSTAT_DATA_UINT64, "mmac_addr_1"}, {MMAC_ADDR_POOL2, KSTAT_DATA_UINT64, "mmac_addr_2"}, {MMAC_ADDR_POOL3, KSTAT_DATA_UINT64, "mmac_addr_3"}, {MMAC_ADDR_POOL4, KSTAT_DATA_UINT64, "mmac_addr_4"}, {MMAC_ADDR_POOL5, KSTAT_DATA_UINT64, "mmac_addr_5"}, {MMAC_ADDR_POOL6, KSTAT_DATA_UINT64, "mmac_addr_6"}, {MMAC_ADDR_POOL7, KSTAT_DATA_UINT64, "mmac_addr_7"}, {MMAC_ADDR_POOL8, KSTAT_DATA_UINT64, "mmac_addr_8"}, {MMAC_ADDR_POOL9, KSTAT_DATA_UINT64, "mmac_addr_9"}, {MMAC_ADDR_POOL10, KSTAT_DATA_UINT64, "mmac_addr_10"}, {MMAC_ADDR_POOL11, KSTAT_DATA_UINT64, "mmac_addr_11"}, {MMAC_ADDR_POOL12, KSTAT_DATA_UINT64, "mmac_addr_12"}, {MMAC_ADDR_POOL13, KSTAT_DATA_UINT64, "mmac_addr_13"}, {MMAC_ADDR_POOL14, KSTAT_DATA_UINT64, "mmac_addr_14"}, {MMAC_ADDR_POOL15, KSTAT_DATA_UINT64, "mmac_addr_15"}, {MMAC_ADDR_POOL16, KSTAT_DATA_UINT64, "mmac_addr_16"}, {MMAC_STATS_END, KSTAT_DATA_UINT64, NULL}, }; /* ARGSUSED */ int hxge_tdc_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_tdc_kstat_t tdc_kstatsp; p_hxge_tx_ring_stats_t statsp; int channel; char *ch_name, *end; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_rxstat_update")); ch_name = ksp->ks_name; ch_name += strlen(TDC_NAME_FORMAT1); channel = mi_strtol(ch_name, &end, 10); tdc_kstatsp = (p_hxge_tdc_kstat_t)ksp->ks_data; statsp = (p_hxge_tx_ring_stats_t)&hxgep->statsp->tdc_stats[channel]; HXGE_DEBUG_MSG((hxgep, KST_CTL, "hxge_tdc_stat_update data $%p statsp $%p channel %d", ksp->ks_data, statsp, channel)); tdc_kstatsp->opackets.value.ull = statsp->opackets; tdc_kstatsp->obytes.value.ull = statsp->obytes; tdc_kstatsp->obytes_with_pad.value.ull = statsp->obytes_with_pad; tdc_kstatsp->oerrors.value.ull = statsp->oerrors; tdc_kstatsp->tx_hdr_pkts.value.ull = statsp->tx_hdr_pkts; tdc_kstatsp->tx_ddi_pkts.value.ull = statsp->tx_ddi_pkts; tdc_kstatsp->tx_jumbo_pkts.value.ull = statsp->tx_jumbo_pkts; tdc_kstatsp->tx_max_pend.value.ull = statsp->tx_max_pend; tdc_kstatsp->peu_resp_err.value.ul = statsp->peu_resp_err; tdc_kstatsp->pkt_size_err.value.ul = statsp->pkt_size_err; tdc_kstatsp->tx_rng_oflow.value.ul = statsp->tx_rng_oflow; tdc_kstatsp->pkt_size_hdr_err.value.ul = statsp->pkt_size_hdr_err; tdc_kstatsp->runt_pkt_drop_err.value.ul = statsp->runt_pkt_drop_err; tdc_kstatsp->pref_par_err.value.ul = statsp->pref_par_err; tdc_kstatsp->tdr_pref_cpl_to.value.ul = statsp->tdr_pref_cpl_to; tdc_kstatsp->pkt_cpl_to.value.ul = statsp->pkt_cpl_to; tdc_kstatsp->invalid_sop.value.ul = statsp->invalid_sop; tdc_kstatsp->unexpected_sop.value.ul = statsp->unexpected_sop; tdc_kstatsp->tx_starts.value.ul = statsp->tx_starts; tdc_kstatsp->tx_no_desc.value.ul = statsp->tx_no_desc; tdc_kstatsp->tx_dma_bind_fail.value.ul = statsp->tx_dma_bind_fail; tdc_kstatsp->count_hdr_size_err.value.ul = statsp->count_hdr_size_err; tdc_kstatsp->count_runt.value.ul = statsp->count_runt; tdc_kstatsp->count_abort.value.ul = statsp->count_abort; tdc_kstatsp->tx_marks.value.ul = statsp->tx_marks; HXGE_DEBUG_MSG((hxgep, KST_CTL, " <== hxge_tdc_stat_update")); return (0); } /* ARGSUSED */ int hxge_tdc_sys_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_tdc_sys_kstat_t tdc_sys_kstatsp; p_hxge_tdc_sys_stats_t statsp; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_tdc_sys_stat_update")); tdc_sys_kstatsp = (p_hxge_tdc_sys_kstat_t)ksp->ks_data; statsp = (p_hxge_tdc_sys_stats_t)&hxgep->statsp->tdc_sys_stats; HXGE_DEBUG_MSG((hxgep, KST_CTL, "hxge_tdc_sys_stat_update %llx", ksp->ks_data)); tdc_sys_kstatsp->reord_tbl_par_err.value.ul = statsp->reord_tbl_par_err; tdc_sys_kstatsp->reord_buf_ded_err.value.ul = statsp->reord_buf_ded_err; tdc_sys_kstatsp->reord_buf_sec_err.value.ul = statsp->reord_buf_sec_err; HXGE_DEBUG_MSG((hxgep, KST_CTL, " <== hxge_tdc_sys_stat_update")); return (0); } /* ARGSUSED */ int hxge_rdc_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_rdc_kstat_t rdc_kstatsp; p_hxge_rx_ring_stats_t statsp; int channel; char *ch_name, *end; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_rdc_stat_update")); ch_name = ksp->ks_name; ch_name += strlen(RDC_NAME_FORMAT1); channel = mi_strtol(ch_name, &end, 10); rdc_kstatsp = (p_hxge_rdc_kstat_t)ksp->ks_data; statsp = (p_hxge_rx_ring_stats_t)&hxgep->statsp->rdc_stats[channel]; HXGE_DEBUG_MSG((hxgep, KST_CTL, "hxge_rdc_stat_update $%p statsp $%p channel %d", ksp->ks_data, statsp, channel)); rdc_kstatsp->ipackets.value.ull = statsp->ipackets; rdc_kstatsp->rbytes.value.ull = statsp->ibytes; rdc_kstatsp->jumbo_pkts.value.ul = statsp->jumbo_pkts; rdc_kstatsp->rcr_unknown_err.value.ul = statsp->rcr_unknown_err; rdc_kstatsp->errors.value.ul = statsp->ierrors; rdc_kstatsp->rcr_sha_par_err.value.ul = statsp->rcr_sha_par; rdc_kstatsp->rbr_pre_par_err.value.ul = statsp->rbr_pre_par; rdc_kstatsp->rbr_pre_emty.value.ul = statsp->rbr_pre_empty; rdc_kstatsp->rcr_shadow_full.value.ul = statsp->rcr_shadow_full; rdc_kstatsp->rbr_tmout.value.ul = statsp->rbr_tmout; rdc_kstatsp->peu_resp_err.value.ul = statsp->peu_resp_err; rdc_kstatsp->ctrl_fifo_ecc_err.value.ul = statsp->ctrl_fifo_ecc_err; rdc_kstatsp->data_fifo_ecc_err.value.ul = statsp->data_fifo_ecc_err; rdc_kstatsp->rcrfull.value.ul = statsp->rcrfull; rdc_kstatsp->rbr_empty.value.ul = statsp->rbr_empty; rdc_kstatsp->rbr_empty_fail.value.ul = statsp->rbr_empty_fail; rdc_kstatsp->rbr_empty_restore.value.ul = statsp->rbr_empty_restore; rdc_kstatsp->rbrfull.value.ul = statsp->rbrfull; rdc_kstatsp->rcr_invalids.value.ul = statsp->rcr_invalids; rdc_kstatsp->rcr_to.value.ul = statsp->rcr_to; rdc_kstatsp->rcr_thresh.value.ul = statsp->rcr_thres; rdc_kstatsp->pkt_drop.value.ul = statsp->pkt_drop; HXGE_DEBUG_MSG((hxgep, KST_CTL, " <== hxge_rdc_stat_update")); return (0); } /* ARGSUSED */ int hxge_rdc_sys_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_rdc_sys_kstat_t rdc_sys_kstatsp; p_hxge_rdc_sys_stats_t statsp; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_rdc_sys_stat_update")); rdc_sys_kstatsp = (p_hxge_rdc_sys_kstat_t)ksp->ks_data; statsp = (p_hxge_rdc_sys_stats_t)&hxgep->statsp->rdc_sys_stats; HXGE_DEBUG_MSG((hxgep, KST_CTL, "hxge_rdc_sys_stat_update %llx", ksp->ks_data)); rdc_sys_kstatsp->ctrl_fifo_sec.value.ul = statsp->ctrl_fifo_sec; rdc_sys_kstatsp->ctrl_fifo_ded.value.ul = statsp->ctrl_fifo_ded; rdc_sys_kstatsp->data_fifo_sec.value.ul = statsp->data_fifo_sec; rdc_sys_kstatsp->data_fifo_ded.value.ul = statsp->data_fifo_ded; HXGE_DEBUG_MSG((hxgep, KST_CTL, " <== hxge_rdc_sys_stat_update")); return (0); } /* ARGSUSED */ int hxge_vmac_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_vmac_kstat_t vmac_kstatsp; p_hxge_vmac_stats_t statsp; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_vmac_stat_update")); hxge_save_cntrs(hxgep); vmac_kstatsp = (p_hxge_vmac_kstat_t)ksp->ks_data; statsp = (p_hxge_vmac_stats_t)&hxgep->statsp->vmac_stats; vmac_kstatsp->tx_frame_cnt.value.ul = statsp->tx_frame_cnt; vmac_kstatsp->tx_byte_cnt.value.ul = statsp->tx_byte_cnt; vmac_kstatsp->rx_frame_cnt.value.ul = statsp->rx_frame_cnt; vmac_kstatsp->rx_byte_cnt.value.ul = statsp->rx_byte_cnt; vmac_kstatsp->rx_drop_frame_cnt.value.ul = statsp->rx_drop_frame_cnt; vmac_kstatsp->rx_drop_byte_cnt.value.ul = statsp->rx_drop_byte_cnt; vmac_kstatsp->rx_crc_cnt.value.ul = statsp->rx_crc_cnt; vmac_kstatsp->rx_pause_cnt.value.ul = statsp->rx_pause_cnt; vmac_kstatsp->rx_bcast_fr_cnt.value.ul = statsp->rx_bcast_fr_cnt; vmac_kstatsp->rx_mcast_fr_cnt.value.ul = statsp->rx_mcast_fr_cnt; HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_vmac_stat_update")); return (0); } /* ARGSUSED */ int hxge_pfc_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_pfc_kstat_t kstatsp; p_hxge_pfc_stats_t statsp; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_pfc_stat_update")); kstatsp = (p_hxge_pfc_kstat_t)ksp->ks_data; statsp = (p_hxge_pfc_stats_t)&hxgep->statsp->pfc_stats; kstatsp->pfc_pkt_drop.value.ul = statsp->pkt_drop; kstatsp->pfc_tcam_parity_err.value.ul = statsp->tcam_parity_err; kstatsp->pfc_vlan_parity_err.value.ul = statsp->vlan_parity_err; kstatsp->pfc_bad_cs_count.value.ul = statsp->bad_cs_count; kstatsp->pfc_drop_count.value.ul = statsp->drop_count; kstatsp->pfc_tcp_ctrl_drop.value.ul = statsp->errlog.tcp_ctrl_drop; kstatsp->pfc_l2_addr_drop.value.ul = statsp->errlog.l2_addr_drop; kstatsp->pfc_class_code_drop.value.ul = statsp->errlog.class_code_drop; kstatsp->pfc_tcam_drop.value.ul = statsp->errlog.tcam_drop; kstatsp->pfc_vlan_drop.value.ul = statsp->errlog.vlan_drop; HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_pfc_stat_update")); return (0); } /* ARGSUSED */ int hxge_peu_sys_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_peu_sys_kstat_t peu_kstatsp; p_hxge_peu_sys_stats_t statsp; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_peu_sys_stat_update")); peu_kstatsp = (p_hxge_peu_sys_kstat_t)ksp->ks_data; statsp = (p_hxge_peu_sys_stats_t)&hxgep->statsp->peu_sys_stats; peu_kstatsp->spc_acc_err.value.ul = statsp->spc_acc_err; peu_kstatsp->tdc_pioacc_err.value.ul = statsp->tdc_pioacc_err; peu_kstatsp->rdc_pioacc_err.value.ul = statsp->rdc_pioacc_err; peu_kstatsp->pfc_pioacc_err.value.ul = statsp->pfc_pioacc_err; peu_kstatsp->vmac_pioacc_err.value.ul = statsp->vmac_pioacc_err; peu_kstatsp->cpl_hdrq_parerr.value.ul = statsp->cpl_hdrq_parerr; peu_kstatsp->cpl_dataq_parerr.value.ul = statsp->cpl_dataq_parerr; peu_kstatsp->retryram_xdlh_parerr.value.ul = statsp->retryram_xdlh_parerr; peu_kstatsp->retrysotram_xdlh_parerr.value.ul = statsp->retrysotram_xdlh_parerr; peu_kstatsp->p_hdrq_parerr.value.ul = statsp->p_hdrq_parerr; peu_kstatsp->p_dataq_parerr.value.ul = statsp->p_dataq_parerr; peu_kstatsp->np_hdrq_parerr.value.ul = statsp->np_hdrq_parerr; peu_kstatsp->np_dataq_parerr.value.ul = statsp->np_dataq_parerr; peu_kstatsp->eic_msix_parerr.value.ul = statsp->eic_msix_parerr; peu_kstatsp->hcr_parerr.value.ul = statsp->hcr_parerr; HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_peu_sys_stat_update")); return (0); } static kstat_t * hxge_setup_local_kstat(p_hxge_t hxgep, int instance, char *name, const hxge_kstat_index_t *ksip, size_t count, int (*update) (kstat_t *, int)) { kstat_t *ksp; kstat_named_t *knp; int i; ksp = kstat_create(HXGE_DRIVER_NAME, instance, name, "net", KSTAT_TYPE_NAMED, count, 0); if (ksp == NULL) return (NULL); ksp->ks_private = (void *) hxgep; ksp->ks_update = update; knp = ksp->ks_data; for (i = 0; ksip[i].name != NULL; i++) { kstat_named_init(&knp[i], ksip[i].name, ksip[i].type); } kstat_install(ksp); return (ksp); } void hxge_setup_kstats(p_hxge_t hxgep) { struct kstat *ksp; p_hxge_port_kstat_t hxgekp; size_t hxge_kstat_sz; char stat_name[64]; int i; HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_setup_kstats")); /* Setup RDC statistics */ for (i = 0; i < hxgep->nrdc; i++) { (void) sprintf(stat_name, "%s"CH_NAME_FORMAT, RDC_NAME_FORMAT1, i); hxgep->statsp->rdc_ksp[i] = hxge_setup_local_kstat(hxgep, hxgep->instance, stat_name, &hxge_rdc_stats[0], RDC_STAT_END, hxge_rdc_stat_update); if (hxgep->statsp->rdc_ksp[i] == NULL) cmn_err(CE_WARN, "kstat_create failed for rdc channel %d", i); } /* Setup RDC System statistics */ hxgep->statsp->rdc_sys_ksp = hxge_setup_local_kstat(hxgep, hxgep->instance, "RDC_system", &hxge_rdc_sys_stats[0], RDC_SYS_STAT_END, hxge_rdc_sys_stat_update); if (hxgep->statsp->rdc_sys_ksp == NULL) cmn_err(CE_WARN, "kstat_create failed for rdc_sys_ksp"); /* Setup TDC statistics */ for (i = 0; i < hxgep->ntdc; i++) { (void) sprintf(stat_name, "%s"CH_NAME_FORMAT, TDC_NAME_FORMAT1, i); hxgep->statsp->tdc_ksp[i] = hxge_setup_local_kstat(hxgep, hxgep->instance, stat_name, &hxge_tdc_stats[0], TDC_STAT_END, hxge_tdc_stat_update); if (hxgep->statsp->tdc_ksp[i] == NULL) cmn_err(CE_WARN, "kstat_create failed for tdc channel %d", i); } /* Setup TDC System statistics */ hxgep->statsp->tdc_sys_ksp = hxge_setup_local_kstat(hxgep, hxgep->instance, "TDC_system", &hxge_tdc_sys_stats[0], RDC_SYS_STAT_END, hxge_tdc_sys_stat_update); if (hxgep->statsp->tdc_sys_ksp == NULL) cmn_err(CE_WARN, "kstat_create failed for tdc_sys_ksp"); /* Setup PFC statistics */ hxgep->statsp->pfc_ksp = hxge_setup_local_kstat(hxgep, hxgep->instance, "PFC", &hxge_pfc_stats[0], PFC_STAT_END, hxge_pfc_stat_update); if (hxgep->statsp->pfc_ksp == NULL) cmn_err(CE_WARN, "kstat_create failed for pfc"); /* Setup VMAC statistics */ hxgep->statsp->vmac_ksp = hxge_setup_local_kstat(hxgep, hxgep->instance, "VMAC", &hxge_vmac_stats[0], VMAC_STAT_END, hxge_vmac_stat_update); if (hxgep->statsp->vmac_ksp == NULL) cmn_err(CE_WARN, "kstat_create failed for vmac"); /* Setup MMAC Statistics. */ hxgep->statsp->mmac_ksp = hxge_setup_local_kstat(hxgep, hxgep->instance, "MMAC", &hxge_mmac_stats[0], MMAC_STATS_END, hxge_mmac_stat_update); if (hxgep->statsp->mmac_ksp == NULL) cmn_err(CE_WARN, "kstat_create failed for mmac"); /* Setup PEU System statistics */ hxgep->statsp->peu_sys_ksp = hxge_setup_local_kstat(hxgep, hxgep->instance, "PEU", &hxge_peu_sys_stats[0], PEU_SYS_STAT_END, hxge_peu_sys_stat_update); if (hxgep->statsp->peu_sys_ksp == NULL) cmn_err(CE_WARN, "kstat_create failed for peu sys"); /* Port stats */ hxge_kstat_sz = sizeof (hxge_port_kstat_t); if ((ksp = kstat_create(HXGE_DRIVER_NAME, hxgep->instance, "Port", "net", KSTAT_TYPE_NAMED, hxge_kstat_sz / sizeof (kstat_named_t), 0)) == NULL) { cmn_err(CE_WARN, "kstat_create failed for port stat"); return; } hxgekp = (p_hxge_port_kstat_t)ksp->ks_data; kstat_named_init(&hxgekp->cap_10gfdx, "cap_10gfdx", KSTAT_DATA_ULONG); /* * Link partner capabilities. */ kstat_named_init(&hxgekp->lp_cap_10gfdx, "lp_cap_10gfdx", KSTAT_DATA_ULONG); /* * Shared link setup. */ kstat_named_init(&hxgekp->link_speed, "link_speed", KSTAT_DATA_ULONG); kstat_named_init(&hxgekp->link_duplex, "link_duplex", KSTAT_DATA_CHAR); kstat_named_init(&hxgekp->link_up, "link_up", KSTAT_DATA_ULONG); /* * Loopback statistics. */ kstat_named_init(&hxgekp->lb_mode, "lb_mode", KSTAT_DATA_ULONG); /* General MAC statistics */ kstat_named_init(&hxgekp->ifspeed, "ifspeed", KSTAT_DATA_UINT64); kstat_named_init(&hxgekp->promisc, "promisc", KSTAT_DATA_CHAR); ksp->ks_update = hxge_port_kstat_update; ksp->ks_private = (void *) hxgep; kstat_install(ksp); hxgep->statsp->port_ksp = ksp; HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_setup_kstats")); } void hxge_destroy_kstats(p_hxge_t hxgep) { int channel; p_hxge_dma_pt_cfg_t p_dma_cfgp; p_hxge_hw_pt_cfg_t p_cfgp; HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_destroy_kstats")); if (hxgep->statsp == NULL) return; if (hxgep->statsp->ksp) kstat_delete(hxgep->statsp->ksp); p_dma_cfgp = (p_hxge_dma_pt_cfg_t)&hxgep->pt_config; p_cfgp = (p_hxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config; for (channel = 0; channel < p_cfgp->max_rdcs; channel++) { if (hxgep->statsp->rdc_ksp[channel]) { kstat_delete(hxgep->statsp->rdc_ksp[channel]); } } for (channel = 0; channel < p_cfgp->max_tdcs; channel++) { if (hxgep->statsp->tdc_ksp[channel]) { kstat_delete(hxgep->statsp->tdc_ksp[channel]); } } if (hxgep->statsp->rdc_sys_ksp) kstat_delete(hxgep->statsp->rdc_sys_ksp); if (hxgep->statsp->tdc_sys_ksp) kstat_delete(hxgep->statsp->tdc_sys_ksp); if (hxgep->statsp->peu_sys_ksp) kstat_delete(hxgep->statsp->peu_sys_ksp); if (hxgep->statsp->mmac_ksp) kstat_delete(hxgep->statsp->mmac_ksp); if (hxgep->statsp->pfc_ksp) kstat_delete(hxgep->statsp->pfc_ksp); if (hxgep->statsp->vmac_ksp) kstat_delete(hxgep->statsp->vmac_ksp); if (hxgep->statsp->port_ksp) kstat_delete(hxgep->statsp->port_ksp); if (hxgep->statsp) KMEM_FREE(hxgep->statsp, hxgep->statsp->stats_size); HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_destroy_kstats")); } /* ARGSUSED */ int hxge_port_kstat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_stats_t statsp; p_hxge_port_kstat_t hxgekp; p_hxge_port_stats_t psp; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_port_kstat_update")); statsp = (p_hxge_stats_t)hxgep->statsp; hxgekp = (p_hxge_port_kstat_t)ksp->ks_data; psp = &statsp->port_stats; if (hxgep->filter.all_phys_cnt) (void) strcpy(hxgekp->promisc.value.c, "phys"); else if (hxgep->filter.all_multicast_cnt) (void) strcpy(hxgekp->promisc.value.c, "multi"); else (void) strcpy(hxgekp->promisc.value.c, "off"); hxgekp->ifspeed.value.ul = statsp->mac_stats.link_speed * 1000000ULL; /* * transceiver state informations. */ hxgekp->cap_10gfdx.value.ul = statsp->mac_stats.cap_10gfdx; /* * Link partner capabilities. */ hxgekp->lp_cap_10gfdx.value.ul = statsp->mac_stats.lp_cap_10gfdx; /* * Physical link statistics. */ hxgekp->link_speed.value.ul = statsp->mac_stats.link_speed; if (statsp->mac_stats.link_duplex == 2) (void) strcpy(hxgekp->link_duplex.value.c, "full"); else (void) strcpy(hxgekp->link_duplex.value.c, "unknown"); hxgekp->link_up.value.ul = statsp->mac_stats.link_up; /* * Loopback statistics. */ hxgekp->lb_mode.value.ul = psp->lb_mode; HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_port_kstat_update")); return (0); } /* * Retrieve a value for one of the statistics for a particular rx ring */ int hxge_rx_ring_stat(mac_ring_driver_t rdriver, uint_t stat, uint64_t *val) { p_hxge_ring_handle_t rhp = (p_hxge_ring_handle_t)rdriver; p_hxge_t hxgep = rhp->hxgep; ASSERT(rhp != NULL); ASSERT(hxgep != NULL); ASSERT(hxgep->statsp != NULL); ASSERT((rhp->index >= 0) && (rhp->index < HXGE_MAX_RDCS)); switch (stat) { case MAC_STAT_IERRORS: *val = hxgep->statsp->rdc_stats[rhp->index].ierrors; break; case MAC_STAT_RBYTES: *val = hxgep->statsp->rdc_stats[rhp->index].ibytes; break; case MAC_STAT_IPACKETS: *val = hxgep->statsp->rdc_stats[rhp->index].ipackets; break; default: *val = 0; return (ENOTSUP); } return (0); } /* * Retrieve a value for one of the statistics for a particular tx ring */ int hxge_tx_ring_stat(mac_ring_driver_t rdriver, uint_t stat, uint64_t *val) { p_hxge_ring_handle_t rhp = (p_hxge_ring_handle_t)rdriver; p_hxge_t hxgep = rhp->hxgep; ASSERT(rhp != NULL); ASSERT(hxgep != NULL); ASSERT(hxgep->statsp != NULL); ASSERT((rhp->index >= 0) && (rhp->index < HXGE_MAX_TDCS)); switch (stat) { case MAC_STAT_OERRORS: *val = hxgep->statsp->tdc_stats[rhp->index].oerrors; break; case MAC_STAT_OBYTES: *val = hxgep->statsp->tdc_stats[rhp->index].obytes; break; case MAC_STAT_OPACKETS: *val = hxgep->statsp->tdc_stats[rhp->index].opackets; break; default: *val = 0; return (ENOTSUP); } return (0); } int hxge_m_stat(void *arg, uint_t stat, uint64_t *value) { p_hxge_t hxgep = (p_hxge_t)arg; p_hxge_stats_t statsp; hxge_tx_ring_stats_t *tx_stats; uint64_t val = 0; int channel; HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_m_stat")); statsp = (p_hxge_stats_t)hxgep->statsp; switch (stat) { case MAC_STAT_IFSPEED: val = statsp->mac_stats.link_speed * 1000000ull; break; case MAC_STAT_MULTIRCV: val = 0; break; case MAC_STAT_BRDCSTRCV: val = 0; break; case MAC_STAT_MULTIXMT: val = 0; break; case MAC_STAT_BRDCSTXMT: val = 0; break; case MAC_STAT_NORCVBUF: val = 0; break; case MAC_STAT_IERRORS: case ETHER_STAT_MACRCV_ERRORS: val = 0; for (channel = 0; channel < hxgep->nrdc; channel++) { val += statsp->rdc_stats[channel].ierrors; } break; case MAC_STAT_NOXMTBUF: val = 0; break; case MAC_STAT_OERRORS: for (channel = 0; channel < hxgep->ntdc; channel++) { val += statsp->tdc_stats[channel].oerrors; } break; case MAC_STAT_COLLISIONS: val = 0; break; case MAC_STAT_RBYTES: for (channel = 0; channel < hxgep->nrdc; channel++) { val += statsp->rdc_stats[channel].ibytes; } break; case MAC_STAT_IPACKETS: for (channel = 0; channel < hxgep->nrdc; channel++) { val += statsp->rdc_stats[channel].ipackets; } break; case MAC_STAT_OBYTES: for (channel = 0; channel < hxgep->ntdc; channel++) { val += statsp->tdc_stats[channel].obytes; } break; case MAC_STAT_OPACKETS: for (channel = 0; channel < hxgep->ntdc; channel++) { val += statsp->tdc_stats[channel].opackets; } break; case MAC_STAT_UNKNOWNS: val = 0; break; case MAC_STAT_UNDERFLOWS: val = 0; break; case MAC_STAT_OVERFLOWS: val = 0; break; case MAC_STAT_LINK_STATE: val = statsp->mac_stats.link_duplex; break; case MAC_STAT_LINK_UP: val = statsp->mac_stats.link_up; break; case MAC_STAT_PROMISC: val = statsp->mac_stats.promisc; break; case ETHER_STAT_SQE_ERRORS: val = 0; break; case ETHER_STAT_ALIGN_ERRORS: /* * No similar error in Hydra receive channels */ val = 0; break; case ETHER_STAT_FCS_ERRORS: /* * No similar error in Hydra receive channels */ val = 0; break; case ETHER_STAT_FIRST_COLLISIONS: val = 0; break; case ETHER_STAT_MULTI_COLLISIONS: val = 0; break; case ETHER_STAT_TX_LATE_COLLISIONS: val = 0; break; case ETHER_STAT_EX_COLLISIONS: val = 0; break; case ETHER_STAT_DEFER_XMTS: val = 0; break; case ETHER_STAT_MACXMT_ERRORS: /* * A count of frames for which transmission on a * particular interface fails due to an internal * MAC sublayer transmit error */ for (channel = 0; channel < hxgep->ntdc; channel++) { tx_stats = &statsp->tdc_stats[channel]; val += tx_stats->pkt_size_hdr_err + tx_stats->pkt_size_err + tx_stats->tx_rng_oflow + tx_stats->peu_resp_err + tx_stats->runt_pkt_drop_err + tx_stats->pref_par_err + tx_stats->tdr_pref_cpl_to + tx_stats->pkt_cpl_to + tx_stats->invalid_sop + tx_stats->unexpected_sop; } break; case ETHER_STAT_CARRIER_ERRORS: /* * The number of times that the carrier sense * condition was lost or never asserted when * attempting to transmit a frame on a particular interface */ for (channel = 0; channel < hxgep->ntdc; channel++) { tx_stats = &statsp->tdc_stats[channel]; val += tx_stats->tdr_pref_cpl_to + tx_stats->pkt_cpl_to; } break; case ETHER_STAT_TOOLONG_ERRORS: /* * A count of frames received on a particular * interface that exceed the maximum permitted frame size */ for (channel = 0; channel < hxgep->ntdc; channel++) { tx_stats = &statsp->tdc_stats[channel]; val += tx_stats->pkt_size_err; } break; case ETHER_STAT_XCVR_ADDR: val = 0; break; case ETHER_STAT_XCVR_ID: val = 0; break; case ETHER_STAT_XCVR_INUSE: val = 0; break; case ETHER_STAT_CAP_1000FDX: val = 0; break; case ETHER_STAT_CAP_1000HDX: val = 0; break; case ETHER_STAT_CAP_100FDX: val = 0; break; case ETHER_STAT_CAP_100HDX: val = 0; break; case ETHER_STAT_CAP_10FDX: val = 0; break; case ETHER_STAT_CAP_10HDX: val = 0; break; case ETHER_STAT_CAP_ASMPAUSE: val = 0; break; case ETHER_STAT_CAP_PAUSE: val = 0; break; case ETHER_STAT_CAP_AUTONEG: val = 0; break; case ETHER_STAT_ADV_CAP_1000FDX: val = 0; break; case ETHER_STAT_ADV_CAP_1000HDX: val = 0; break; case ETHER_STAT_ADV_CAP_100FDX: val = 0; break; case ETHER_STAT_ADV_CAP_100HDX: val = 0; break; case ETHER_STAT_ADV_CAP_10FDX: val = 0; break; case ETHER_STAT_ADV_CAP_10HDX: val = 0; break; case ETHER_STAT_ADV_CAP_ASMPAUSE: val = 0; break; case ETHER_STAT_ADV_CAP_PAUSE: val = 0; break; case ETHER_STAT_ADV_CAP_AUTONEG: val = 0; break; case ETHER_STAT_LP_CAP_1000FDX: val = 0; break; case ETHER_STAT_LP_CAP_1000HDX: val = 0; break; case ETHER_STAT_LP_CAP_100FDX: val = 0; break; case ETHER_STAT_LP_CAP_100HDX: val = 0; break; case ETHER_STAT_LP_CAP_10FDX: val = 0; break; case ETHER_STAT_LP_CAP_10HDX: val = 0; break; case ETHER_STAT_LP_CAP_ASMPAUSE: val = 0; break; case ETHER_STAT_LP_CAP_PAUSE: val = 0; break; case ETHER_STAT_LP_CAP_AUTONEG: val = 0; break; case ETHER_STAT_LINK_ASMPAUSE: val = 0; break; case ETHER_STAT_LINK_PAUSE: val = 0; break; case ETHER_STAT_LINK_AUTONEG: val = 0; break; case ETHER_STAT_LINK_DUPLEX: val = statsp->mac_stats.link_duplex; break; case ETHER_STAT_TOOSHORT_ERRORS: val = 0; break; case ETHER_STAT_CAP_REMFAULT: val = 0; break; case ETHER_STAT_ADV_REMFAULT: val = 0; break; case ETHER_STAT_LP_REMFAULT: val = 0; break; case ETHER_STAT_JABBER_ERRORS: val = 0; break; case ETHER_STAT_CAP_100T4: val = 0; break; case ETHER_STAT_ADV_CAP_100T4: val = 0; break; case ETHER_STAT_LP_CAP_100T4: val = 0; break; case ETHER_STAT_ADV_CAP_10GFDX: case ETHER_STAT_CAP_10GFDX: case ETHER_STAT_LP_CAP_10GFDX: val = 0; break; default: /* * Shouldn't reach here... */ cmn_err(CE_WARN, "hxge_m_stat: unrecognized parameter value = 0x%x", stat); return (ENOTSUP); } *value = val; return (0); } static uint64_t hxge_mac_octet_to_u64(uint8_t *addr) { int i; uint64_t addr64 = 0; for (i = ETHERADDRL - 1; i >= 0; i--) { addr64 <<= 8; addr64 |= addr[i]; } return (addr64); } /*ARGSUSED*/ static int hxge_mmac_stat_update(kstat_t *ksp, int rw) { p_hxge_t hxgep; p_hxge_mmac_kstat_t mmac_kstatsp; hxgep = (p_hxge_t)ksp->ks_private; if (hxgep == NULL) return (-1); HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_mmac_stat_update")); if (rw == KSTAT_WRITE) { cmn_err(CE_WARN, "Can not write mmac stats"); } else { MUTEX_ENTER(hxgep->genlock); mmac_kstatsp = (p_hxge_mmac_kstat_t)ksp->ks_data; mmac_kstatsp->mmac_max_addr_cnt.value.ul = hxgep->mmac.total; mmac_kstatsp->mmac_avail_addr_cnt.value.ul = hxgep->mmac.available; mmac_kstatsp->mmac_addr1.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[0].addr); mmac_kstatsp->mmac_addr2.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[1].addr); mmac_kstatsp->mmac_addr3.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[2].addr); mmac_kstatsp->mmac_addr4.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[3].addr); mmac_kstatsp->mmac_addr5.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[4].addr); mmac_kstatsp->mmac_addr6.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[5].addr); mmac_kstatsp->mmac_addr7.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[6].addr); mmac_kstatsp->mmac_addr8.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[7].addr); mmac_kstatsp->mmac_addr9.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[8].addr); mmac_kstatsp->mmac_addr10.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[9].addr); mmac_kstatsp->mmac_addr11.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[10].addr); mmac_kstatsp->mmac_addr12.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[11].addr); mmac_kstatsp->mmac_addr13.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[12].addr); mmac_kstatsp->mmac_addr14.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[13].addr); mmac_kstatsp->mmac_addr15.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[14].addr); mmac_kstatsp->mmac_addr16.value.ul = hxge_mac_octet_to_u64(hxgep->mmac.addrs[15].addr); MUTEX_EXIT(hxgep->genlock); } HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_mmac_stat_update")); return (0); }