u64  lro_pkts;
        u64  rxbytes;
        u64  txbytes;
+       u64  lrobytes;
+       u64  lso_frames;
+       u64  xmit_on;
+       u64  xmit_off;
+       u64  skb_alloc_failure;
 };
 
 /*
 
                QLC_SIZEOF(stats.rxbytes), QLC_OFF(stats.rxbytes)},
        {"tx_bytes",
                QLC_SIZEOF(stats.txbytes), QLC_OFF(stats.txbytes)},
+       {"lrobytes",
+               QLC_SIZEOF(stats.lrobytes), QLC_OFF(stats.lrobytes)},
+       {"lso_frames",
+               QLC_SIZEOF(stats.lso_frames), QLC_OFF(stats.lso_frames)},
+       {"xmit_on",
+               QLC_SIZEOF(stats.xmit_on), QLC_OFF(stats.xmit_on)},
+       {"xmit_off",
+               QLC_SIZEOF(stats.xmit_off), QLC_OFF(stats.xmit_off)},
+       {"skb_alloc_failure", QLC_SIZEOF(stats.skb_alloc_failure),
+               QLC_OFF(stats.skb_alloc_failure)},
+
 };
 
 #define QLCNIC_STATS_LEN       ARRAY_SIZE(qlcnic_gstrings_stats)
 
        if (nr_desc >= qlcnic_tx_avail(tx_ring)) {
                netif_tx_stop_queue(tx_ring->txq);
                __netif_tx_unlock_bh(tx_ring->txq);
+               adapter->stats.xmit_off++;
                return -EBUSY;
        }
 
 
        struct pci_dev *pdev = adapter->pdev;
 
        buffer->skb = dev_alloc_skb(rds_ring->skb_size);
-       if (!buffer->skb)
+       if (!buffer->skb) {
+               adapter->stats.skb_alloc_failure++;
                return -ENOMEM;
+       }
 
        skb = buffer->skb;
 
        netif_receive_skb(skb);
 
        adapter->stats.lro_pkts++;
-       adapter->stats.rxbytes += length;
+       adapter->stats.lrobytes += length;
 
        return buffer;
 }
                adapter->diag_cnt++;
 
        dev_kfree_skb_any(skb);
+       adapter->stats.rx_pkts++;
+       adapter->stats.rxbytes += length;
 
        return buffer;
 }
 
        if (qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH) {
                netif_stop_queue(adapter->netdev);
                smp_mb();
+               adapter->stats.xmit_off++;
        }
 }
 
        int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
        struct cmd_desc_type0 *hwdesc;
        struct vlan_ethhdr *vh;
+       struct qlcnic_adapter *adapter = netdev_priv(netdev);
 
        if (protocol == cpu_to_be16(ETH_P_8021Q)) {
 
 
        tx_ring->producer = producer;
        barrier();
+       adapter->stats.lso_frames++;
 }
 
 static int
 
        if (unlikely(no_of_desc + 2 > qlcnic_tx_avail(tx_ring))) {
                netif_stop_queue(netdev);
+               adapter->stats.xmit_off++;
                return NETDEV_TX_BUSY;
        }
 
                        if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
                                netif_wake_queue(netdev);
                                adapter->tx_timeo_cnt = 0;
+                               adapter->stats.xmit_on++;
                        }
                        __netif_tx_unlock(tx_ring->txq);
                }