/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

#include "ena.h"

/*
 * The ENA device provides the following hardware stats. It appears
 * that all stats are available at both a device-level and
 * queue-level. However, Linux and FreeBSD don't implement queue
 * scope. It's not clear how one would implement queue scope because
 * there is nothing in the common code describing how to determine the
 * queue index number. Both the SQ and CQ have device index values,
 * but for a given logical queue they don't always match and so it's
 * not clear what value to use for querying the stats. Therefore,
 * device-wide basic and extended stats come from the device, while
 * queue/ring stats come from driver.
 *
 * From empirical testing, these statistics appear to be cumulative.
 * However, this guarantee is not explicitly documented anywhere in
 * the common code that the author could find.
 *
 * BASIC (ENAHW_GET_STATS_TYPE_BASIC)
 *
 *     - Rx packets/bytes
 *     - Rx drops
 *     - Tx packets/bytes
 *     - Tx drops
 *     - Rx overruns
 *
 * EXTENDED (ENAHW_GET_STATS_TYPE_EXTENDED)
 *
 *     There is no structure defined for these stats in the Linux
 *     driver. Based on the FreeBSD driver, it looks like extended
 *     stats are simply a buffer of C strings? Come back to this
 *     later.
 *
 * ENI (ENAHW_GET_STATS_TYPE_ENI)
 *
 *     - Rx Bandwidth Allowance Exceeded
 *     - Tx Bandwidth Allowance Exceeded
 *     - PPS Allowance Exceeded (presumably for combined Rx/Tx)
 *     - Connection Tracking PPS Allowance Exceeded
 *     - Link-local PPS Allowance Exceeded
 */

void
ena_stat_device_cleanup(ena_t *ena)
{
	if (ena->ena_device_kstat != NULL) {
		kstat_delete(ena->ena_device_kstat);
		ena->ena_device_kstat = NULL;
	}
}

bool
ena_stat_device_init(ena_t *ena)
{
	kstat_t *ksp = kstat_create(ENA_MODULE_NAME,
	    ddi_get_instance(ena->ena_dip), "device", "net", KSTAT_TYPE_NAMED,
	    sizeof (ena_device_stat_t) / sizeof (kstat_named_t),
	    KSTAT_FLAG_VIRTUAL);
	ena_device_stat_t *eds = &ena->ena_device_stat;

	if (ksp == NULL) {
		ena_err(ena, "!failed to create device kstats");
		return (false);
	}

	ena->ena_device_kstat = ksp;
	ksp->ks_data = eds;

	kstat_named_init(&eds->eds_reset_forced, "reset_forced",
	    KSTAT_DATA_UINT64);
	kstat_named_init(&eds->eds_reset_error, "reset_error",
	    KSTAT_DATA_UINT64);
	kstat_named_init(&eds->eds_reset_fatal, "reset_fatal",
	    KSTAT_DATA_UINT64);
	kstat_named_init(&eds->eds_reset_keepalive, "reset_keepalive",
	    KSTAT_DATA_UINT64);
	kstat_named_init(&eds->eds_reset_txstall, "reset_txstall",
	    KSTAT_DATA_UINT64);

	kstat_install(ena->ena_device_kstat);
	return (true);
}

static int
ena_stat_device_basic_update(kstat_t *ksp, int rw)
{
	ena_t *ena = ksp->ks_private;
	ena_basic_stat_t *ebs = ksp->ks_data;
	enahw_resp_desc_t resp;
	enahw_resp_basic_stats_t *stats = &resp.erd_resp.erd_basic_stats;
	bool fetch;
	int ret = 0;

	if (rw == KSTAT_WRITE) {
		return (EACCES);
	}

	mutex_enter(&ena->ena_device_basic_stat_lock);
	fetch = gethrtime() - ena->ena_device_basic_stat_last_update >
	    ENA_BASIC_STATS_MINIMUM_INTERVAL_NS;
	mutex_exit(&ena->ena_device_basic_stat_lock);

	if (!fetch)
		return (0);

	if ((ret = ena_admin_get_basic_stats(ena, &resp)) != 0)
		return (ret);

	mutex_enter(&ena->ena_device_basic_stat_lock);
	ena->ena_device_basic_stat_last_update = gethrtime();

	ebs->ebs_tx_bytes.value.ui64 =
	    ((uint64_t)stats->erbs_tx_bytes_high << 32) |
	    (uint64_t)stats->erbs_tx_bytes_low;
	ebs->ebs_tx_pkts.value.ui64 =
	    ((uint64_t)stats->erbs_tx_pkts_high << 32) |
	    (uint64_t)stats->erbs_tx_pkts_low;
	ebs->ebs_tx_drops.value.ui64 =
	    ((uint64_t)stats->erbs_tx_drops_high << 32) |
	    (uint64_t)stats->erbs_tx_drops_low;

	ebs->ebs_rx_bytes.value.ui64 =
	    ((uint64_t)stats->erbs_rx_bytes_high << 32) |
	    (uint64_t)stats->erbs_rx_bytes_low;
	ebs->ebs_rx_pkts.value.ui64 =
	    ((uint64_t)stats->erbs_rx_pkts_high << 32) |
	    (uint64_t)stats->erbs_rx_pkts_low;
	ebs->ebs_rx_drops.value.ui64 =
	    ((uint64_t)stats->erbs_rx_drops_high << 32) |
	    (uint64_t)stats->erbs_rx_drops_low;
	ebs->ebs_rx_overruns.value.ui64 =
	    ((uint64_t)stats->erbs_rx_overruns_high << 32) |
	    (uint64_t)stats->erbs_rx_overruns_low;

	mutex_exit(&ena->ena_device_basic_stat_lock);

	return (0);
}

void
ena_stat_device_basic_cleanup(ena_t *ena)
{
	if (ena->ena_device_basic_kstat != NULL) {
		mutex_destroy(&ena->ena_device_basic_stat_lock);
		kstat_delete(ena->ena_device_basic_kstat);
		ena->ena_device_basic_kstat = NULL;
	}
}

bool
ena_stat_device_basic_init(ena_t *ena)
{
	kstat_t *ksp = kstat_create(ENA_MODULE_NAME,
	    ddi_get_instance(ena->ena_dip), "device_basic", "net",
	    KSTAT_TYPE_NAMED,
	    sizeof (ena_basic_stat_t) / sizeof (kstat_named_t), 0);
	ena_basic_stat_t *ebs = NULL;

	if (ksp == NULL) {
		ena_err(ena, "!failed to create device_basic kstats");
		return (false);
	}

	mutex_init(&ena->ena_device_basic_stat_lock, NULL, MUTEX_DRIVER,
	    DDI_INTR_PRI(ena->ena_intr_pri));
	ena->ena_device_basic_stat_last_update = 0;

	ena->ena_device_basic_kstat = ksp;
	ebs = ksp->ks_data;
	ksp->ks_update = ena_stat_device_basic_update;
	ksp->ks_private = ena;

	kstat_named_init(&ebs->ebs_tx_bytes, "tx_bytes", KSTAT_DATA_UINT64);
	ebs->ebs_tx_bytes.value.ui64 = 0;
	kstat_named_init(&ebs->ebs_tx_pkts, "tx_packets", KSTAT_DATA_UINT64);
	ebs->ebs_tx_pkts.value.ui64 = 0;
	kstat_named_init(&ebs->ebs_tx_drops, "tx_drops", KSTAT_DATA_UINT64);
	ebs->ebs_tx_drops.value.ui64 = 0;

	kstat_named_init(&ebs->ebs_rx_bytes, "rx_bytes", KSTAT_DATA_UINT64);
	ebs->ebs_rx_bytes.value.ui64 = 0;
	kstat_named_init(&ebs->ebs_rx_pkts, "rx_packets", KSTAT_DATA_UINT64);
	ebs->ebs_rx_pkts.value.ui64 = 0;
	kstat_named_init(&ebs->ebs_rx_drops, "rx_drops", KSTAT_DATA_UINT64);
	ebs->ebs_rx_drops.value.ui64 = 0;
	kstat_named_init(&ebs->ebs_rx_overruns, "rx_overruns",
	    KSTAT_DATA_UINT64);
	ebs->ebs_rx_overruns.value.ui64 = 0;

	kstat_install(ena->ena_device_basic_kstat);
	return (true);
}

static int
ena_stat_device_extended_update(kstat_t *ksp, int rw)
{
	ena_t *ena = ksp->ks_private;
	ena_extended_stat_t *ees = ksp->ks_data;
	enahw_resp_desc_t resp;
	enahw_resp_eni_stats_t *stats = &resp.erd_resp.erd_eni_stats;
	int ret = 0;

	if (rw == KSTAT_WRITE) {
		return (EACCES);
	}

	if ((ret = ena_admin_get_eni_stats(ena, &resp)) != 0) {
		return (ret);
	}

	mutex_enter(&ena->ena_lock);

	ees->ees_bw_in_exceeded.value.ui64 = stats->eres_bw_in_exceeded;
	ees->ees_bw_out_exceeded.value.ui64 = stats->eres_bw_out_exceeded;
	ees->ees_pps_exceeded.value.ui64 = stats->eres_pps_exceeded;
	ees->ees_conns_exceeded.value.ui64 = stats->eres_conns_exceeded;
	ees->ees_linklocal_exceeded.value.ui64 = stats->eres_linklocal_exceeded;

	mutex_exit(&ena->ena_lock);

	return (0);
}

void
ena_stat_device_extended_cleanup(ena_t *ena)
{
	if (ena->ena_device_extended_kstat != NULL) {
		kstat_delete(ena->ena_device_extended_kstat);
		ena->ena_device_extended_kstat = NULL;
	}
}

bool
ena_stat_device_extended_init(ena_t *ena)
{
	kstat_t *ksp = kstat_create(ENA_MODULE_NAME,
	    ddi_get_instance(ena->ena_dip), "device_ext", "net",
	    KSTAT_TYPE_NAMED,
	    sizeof (ena_extended_stat_t) / sizeof (kstat_named_t), 0);
	ena_extended_stat_t *ees;

	if (ksp == NULL) {
		ena_err(ena, "!failed to create device_ext kstats");
		return (false);
	}

	ena->ena_device_extended_kstat = ksp;
	ees = ksp->ks_data;
	ksp->ks_update = ena_stat_device_extended_update;
	ksp->ks_private = ena;

	kstat_named_init(&ees->ees_bw_in_exceeded, "bw_in_exceeded",
	    KSTAT_DATA_UINT64);
	ees->ees_bw_in_exceeded.value.ui64 = 0;

	kstat_named_init(&ees->ees_bw_out_exceeded, "bw_out_exceeded",
	    KSTAT_DATA_UINT64);
	ees->ees_bw_out_exceeded.value.ui64 = 0;

	kstat_named_init(&ees->ees_pps_exceeded, "pps_exceeded",
	    KSTAT_DATA_UINT64);
	ees->ees_pps_exceeded.value.ui64 = 0;

	kstat_named_init(&ees->ees_conns_exceeded, "conns_exceeded",
	    KSTAT_DATA_UINT64);
	ees->ees_conns_exceeded.value.ui64 = 0;

	kstat_named_init(&ees->ees_linklocal_exceeded, "linklocal_exceeded",
	    KSTAT_DATA_UINT64);
	ees->ees_linklocal_exceeded.value.ui64 = 0;

	kstat_install(ena->ena_device_extended_kstat);
	return (true);
}

void
ena_stat_aenq_cleanup(ena_t *ena)
{
	if (ena->ena_aenq_kstat != NULL) {
		kstat_delete(ena->ena_aenq_kstat);
		ena->ena_aenq_kstat = NULL;
	}
}

bool
ena_stat_aenq_init(ena_t *ena)
{
	kstat_t *ksp = kstat_create(ENA_MODULE_NAME,
	    ddi_get_instance(ena->ena_dip), "aenq", "net", KSTAT_TYPE_NAMED,
	    sizeof (ena_aenq_stat_t) / sizeof (kstat_named_t),
	    KSTAT_FLAG_VIRTUAL);
	ena_aenq_stat_t *eas = &ena->ena_aenq_stat;

	if (ksp == NULL) {
		ena_err(ena, "!failed to create aenq kstats");
		return (false);
	}

	ena->ena_aenq_kstat = ksp;
	ksp->ks_data = eas;

	kstat_named_init(&eas->eaes_default, "default", KSTAT_DATA_UINT64);
	eas->eaes_default.value.ui64 = 0;

	kstat_named_init(&eas->eaes_link_change, "link_change",
	    KSTAT_DATA_UINT64);
	eas->eaes_link_change.value.ui64 = 0;

	kstat_named_init(&eas->eaes_notification, "notification",
	    KSTAT_DATA_UINT64);
	eas->eaes_notification.value.ui64 = 0;

	kstat_named_init(&eas->eaes_keep_alive, "keep_alive",
	    KSTAT_DATA_UINT64);
	eas->eaes_keep_alive.value.ui64 = 0;

	kstat_named_init(&eas->eaes_request_reset, "request_reset",
	    KSTAT_DATA_UINT64);
	eas->eaes_request_reset.value.ui64 = 0;

	kstat_named_init(&eas->eaes_fatal_error, "fatal_error",
	    KSTAT_DATA_UINT64);
	eas->eaes_fatal_error.value.ui64 = 0;

	kstat_named_init(&eas->eaes_warning, "warning", KSTAT_DATA_UINT64);
	eas->eaes_warning.value.ui64 = 0;

	kstat_install(ena->ena_aenq_kstat);
	return (true);
}

void
ena_stat_txq_cleanup(ena_txq_t *txq)
{
	if (txq->et_kstat != NULL) {
		kstat_delete(txq->et_kstat);
		txq->et_kstat = NULL;
	}
}

bool
ena_stat_txq_init(ena_txq_t *txq)
{
	ena_t *ena = txq->et_ena;
	kstat_t *ksp;
	char buf[128];
	ena_txq_stat_t *ets = &txq->et_stat;

	(void) snprintf(buf, sizeof (buf), "txq_%d", txq->et_txqs_idx);

	ksp = kstat_create(ENA_MODULE_NAME, ddi_get_instance(ena->ena_dip), buf,
	    "net", KSTAT_TYPE_NAMED,
	    sizeof (ena_txq_stat_t) / sizeof (kstat_named_t),
	    KSTAT_FLAG_VIRTUAL);

	if (ksp == NULL) {
		ena_err(ena, "!failed to create %s kstats", buf);
		return (false);
	}

	txq->et_kstat = ksp;
	ksp->ks_data = ets;

	kstat_named_init(&ets->ets_hck_meoifail, "meoi_fail",
	    KSTAT_DATA_UINT64);
	ets->ets_hck_meoifail.value.ui64 = 0;

	kstat_named_init(&ets->ets_blocked, "blocked", KSTAT_DATA_UINT64);
	ets->ets_blocked.value.ui64 = 0;

	kstat_named_init(&ets->ets_unblocked, "unblocked", KSTAT_DATA_UINT64);
	ets->ets_unblocked.value.ui64 = 0;

	kstat_named_init(&ets->ets_recycled, "recycled", KSTAT_DATA_UINT64);
	ets->ets_recycled.value.ui64 = 0;

	kstat_named_init(&ets->ets_bytes, "bytes", KSTAT_DATA_UINT64);
	ets->ets_bytes.value.ui64 = 0;

	kstat_named_init(&ets->ets_packets, "packets", KSTAT_DATA_UINT64);
	ets->ets_packets.value.ui64 = 0;

	kstat_install(txq->et_kstat);
	return (true);
}

void
ena_stat_rxq_cleanup(ena_rxq_t *rxq)
{
	if (rxq->er_kstat != NULL) {
		kstat_delete(rxq->er_kstat);
		rxq->er_kstat = NULL;
	}
}

bool
ena_stat_rxq_init(ena_rxq_t *rxq)
{
	ena_t *ena = rxq->er_ena;
	kstat_t *ksp;
	char buf[128];
	ena_rxq_stat_t *ers = &rxq->er_stat;

	(void) snprintf(buf, sizeof (buf), "rxq_%d", rxq->er_rxqs_idx);

	ksp = kstat_create(ENA_MODULE_NAME, ddi_get_instance(ena->ena_dip), buf,
	    "net", KSTAT_TYPE_NAMED,
	    sizeof (ena_rxq_stat_t) / sizeof (kstat_named_t),
	    KSTAT_FLAG_VIRTUAL);

	if (ksp == NULL) {
		ena_err(ena, "!failed to create %s kstats", buf);
		return (false);
	}

	rxq->er_kstat = ksp;
	ksp->ks_data = ers;

	kstat_named_init(&ers->ers_packets, "packets", KSTAT_DATA_UINT64);
	ers->ers_packets.value.ui64 = 0;

	kstat_named_init(&ers->ers_bytes, "bytes", KSTAT_DATA_UINT64);
	ers->ers_bytes.value.ui64 = 0;

	kstat_named_init(&ers->ers_multi_desc, "multi_desc", KSTAT_DATA_UINT64);
	ers->ers_multi_desc.value.ui64 = 0;

	kstat_named_init(&ers->ers_allocb_fail, "allocb_fail",
	    KSTAT_DATA_UINT64);
	ers->ers_allocb_fail.value.ui64 = 0;

	kstat_named_init(&ers->ers_intr_limit, "intr_limit", KSTAT_DATA_UINT64);
	ers->ers_intr_limit.value.ui64 = 0;

	kstat_named_init(&ers->ers_hck_ipv4_err, "hck_ipv4_err",
	    KSTAT_DATA_UINT64);
	ers->ers_hck_ipv4_err.value.ui64 = 0;

	kstat_named_init(&ers->ers_hck_l4_err, "hck_l4_err", KSTAT_DATA_UINT64);
	ers->ers_hck_l4_err.value.ui64 = 0;

	kstat_install(rxq->er_kstat);
	return (true);
}

int
ena_ring_rx_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val)
{
	int ret = 0;
	ena_rxq_t *rxq = (ena_rxq_t *)rh;

	mutex_enter(&rxq->er_stat_lock);

	switch (stat) {
	case MAC_STAT_RBYTES:
		*val = rxq->er_stat.ers_bytes.value.ui64;
		break;
	case MAC_STAT_IPACKETS:
		*val = rxq->er_stat.ers_packets.value.ui64;
		break;
	default:
		*val = 0;
		ret = ENOTSUP;
	}

	mutex_exit(&rxq->er_stat_lock);
	return (ret);
}

int
ena_ring_tx_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val)
{
	int ret = 0;
	ena_txq_t *txq = (ena_txq_t *)rh;

	mutex_enter(&txq->et_stat_lock);

	switch (stat) {
	case MAC_STAT_OBYTES:
		*val = txq->et_stat.ets_bytes.value.ui64;
		break;
	case MAC_STAT_OPACKETS:
		*val = txq->et_stat.ets_packets.value.ui64;
		break;
	default:
		*val = 0;
		ret = ENOTSUP;
	}

	mutex_exit(&txq->et_stat_lock);
	return (ret);
}

int
ena_m_stat(void *arg, uint_t stat, uint64_t *val)
{
	ena_t *ena = arg;
	ena_basic_stat_t *ebs;
	int ret = 0;
	bool fetch = false;

	/*
	 * The ENA device does not provide a lot of the stats that a
	 * traditional NIC device would. Return ENOTSUP early for any we don't
	 * support, and avoid a round trip to the controller.
	 */
	switch (stat) {
	case ETHER_STAT_LINK_DUPLEX:
	case MAC_STAT_IFSPEED:
		break;
	case MAC_STAT_IERRORS:
	case MAC_STAT_OERRORS:
	case MAC_STAT_NORCVBUF:
	case MAC_STAT_RBYTES:
	case MAC_STAT_IPACKETS:
	case MAC_STAT_OBYTES:
	case MAC_STAT_OPACKETS:
		fetch = true;
		break;
	default:
		return (ENOTSUP);
	}

	if (fetch) {
		ret = ena_stat_device_basic_update(ena->ena_device_basic_kstat,
		    KSTAT_READ);

		if (ret != 0)
			return (ret);
	}

	mutex_enter(&ena->ena_device_basic_stat_lock);
	ebs = ena->ena_device_basic_kstat->ks_data;

	switch (stat) {
	case ETHER_STAT_LINK_DUPLEX:
		*val = ena->ena_link_duplex;
		break;

	case MAC_STAT_IFSPEED:
		*val = ena->ena_link_speed_mbits * 1000000ULL;
		break;

	case MAC_STAT_NORCVBUF:
		*val = ebs->ebs_rx_overruns.value.ui64;
		break;

	case MAC_STAT_RBYTES:
		*val = ebs->ebs_rx_bytes.value.ui64;
		break;

	case MAC_STAT_IPACKETS:
		*val = ebs->ebs_rx_pkts.value.ui64;
		break;

	case MAC_STAT_IERRORS:
		*val = ebs->ebs_rx_drops.value.ui64;
		break;

	case MAC_STAT_OBYTES:
		*val = ebs->ebs_tx_bytes.value.ui64;
		break;

	case MAC_STAT_OPACKETS:
		*val = ebs->ebs_tx_pkts.value.ui64;
		break;

	case MAC_STAT_OERRORS:
		*val = ebs->ebs_tx_drops.value.ui64;
		break;

	default:
		dev_err(ena->ena_dip, CE_PANIC, "unhandled stat, 0x%x", stat);
	}

	mutex_exit(&ena->ena_device_basic_stat_lock);
	return (ret);
}