/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * iSCSI Software Initiator
 */

#define	ISCSI_ICS_NAMES
#include "iscsi.h"	/* main header */

kstat_item_t	kstat_items_hba[KN_HBA_IDX_MAX] = {
	{"_name", KSTAT_DATA_STRING},
	{"_alias", KSTAT_DATA_STRING},
	{"_cntr_sess", KSTAT_DATA_ULONG}
};

kstat_item_t	kstat_items_sess[KN_SESS_IDX_MAX] = {
	{"_state", KSTAT_DATA_STRING},
	{"_oid", KSTAT_DATA_ULONG},
	{"_hba", KSTAT_DATA_STRING},
	{"_cntr_conn", KSTAT_DATA_ULONG},
	{"_cntr_reset", KSTAT_DATA_ULONG},
	{"_cntr_pkt_pending", KSTAT_DATA_ULONG},
	{"_cmd_sn", KSTAT_DATA_ULONG},
	{"_cmd_sn_exp", KSTAT_DATA_ULONG},
	{"_cmd_sn_max", KSTAT_DATA_ULONG},
	{"_target_name", KSTAT_DATA_STRING},
	{"_target_alias", KSTAT_DATA_STRING},
	{"_tpgt", KSTAT_DATA_ULONG}
};

kstat_item_t	kstat_items_conn[KN_CONN_IDX_MAX] = {
	{"_state", KSTAT_DATA_STRING},
	{"_cid", KSTAT_DATA_ULONG},
	{"_oid", KSTAT_DATA_ULONG},
	{"_session", KSTAT_DATA_STRING},
	{"_err_header_digest", KSTAT_DATA_ULONG},
	{"_err_data_digest", KSTAT_DATA_ULONG},
	{"_err_connection_reset", KSTAT_DATA_ULONG},
	{"_err_protocol_error", KSTAT_DATA_ULONG},
	{"_cntr_tx_bytes", KSTAT_DATA_ULONGLONG},
	{"_cntr_rx_bytes", KSTAT_DATA_ULONGLONG},
	{"_cntr_qactive", KSTAT_DATA_ULONG},
	{"_stat_sn_exp", KSTAT_DATA_ULONG},
	{"_stat_sn_last", KSTAT_DATA_ULONG}
};

int iscsi_hba_kstat_update(kstat_t *ks, int rw);
int iscsi_sess_kstat_update(kstat_t *ks, int rw);
int iscsi_conn_kstat_update(kstat_t *ks, int rw);

/*
 * HBA
 */

/*
 * iscsi_hba_kstat_init - This function registers with the kstat service.
 */
boolean_t
iscsi_hba_kstat_init(iscsi_hba_t *ihp)
{
	char			ks_name[KSTAT_STRLEN];
	iscsi_hba_stats_t	*ihs;
	int			i;

	/*
	 * The name of the KSTAT structure is built.
	 */
	bzero(ks_name, sizeof (ks_name));

	if (snprintf(ks_name, sizeof (ks_name) - 1, iSCSI_HBA_BASE_NAME,
	    ihp->hba_oid) >= sizeof (ks_name)) {
		return (TRUE);
	}

	ihp->stats.ks = kstat_create(iSCSI_MODULE_NAME,
	    ddi_get_instance(ihp->hba_dip), ks_name, iSCSI_CLASS_HBA,
	    KSTAT_TYPE_NAMED, 0, KSTAT_FLAG_VIRTUAL);

	if (ihp->stats.ks == NULL) {
		cmn_err(CE_NOTE, "iscsi kstat creation failed for hba(%d)",
		    ihp->hba_oid);
		return (TRUE);
	}

	ihs = &ihp->stats.ks_data;
	ihp->stats.ks->ks_data = &ihp->stats.ks_data;
	ihp->stats.ks->ks_data_size = sizeof (ihp->stats.ks_data);
	ihp->stats.ks->ks_ndata = KN_HBA_IDX_MAX;

	for (i = 0; i < KN_HBA_IDX_MAX; i++) {
		kstat_named_init(&ihs->kn[i], kstat_items_hba[i]._name,
		    kstat_items_hba[i]._data_type);
	}

	ihp->stats.ks->ks_update = iscsi_hba_kstat_update;
	ihp->stats.ks->ks_private = (void *)ihp;

	kstat_install(ihp->stats.ks);

	return (FALSE);
}

/*
 * iscsi_hba_kstat_term - This function deregisters from the kstat service.
 */
boolean_t
iscsi_hba_kstat_term(iscsi_hba_t *ihp)
{
	kstat_delete(ihp->stats.ks);
	return (FALSE);
}

/*
 * iscsi_hba_kstat_update - This function update the kstat structure of the HBA.
 */
int
iscsi_hba_kstat_update(kstat_t *ks, int rw)
{
	iscsi_hba_t		*ihp = (iscsi_hba_t *)ks->ks_private;
	iscsi_hba_stats_t	*ihs = &ihp->stats.ks_data;

	if (rw == KSTAT_READ) {
		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
		bcopy(ihp->hba_name, ihs->name, ihp->hba_name_length);

		bcopy(ihp->hba_alias, ihs->alias, ihp->hba_alias_length);

		ihs->name[ihp->hba_name_length] = 0;
		ihs->alias[ihp->hba_alias_length] = 0;

		kstat_named_setstr(&ihs->kn[KN_HBA_IDX_NAME],
		    (const char *)ihs->name);
		kstat_named_setstr(&ihs->kn[KN_HBA_IDX_ALIAS],
		    (const char *)ihs->alias);
		rw_exit(&ihp->hba_sess_list_rwlock);
	}
	return (0);
}

/*
 * Session
 */

/*
 * iscsi_sess_kstat_init - This function registers with the kstat service.
 */
boolean_t
iscsi_sess_kstat_init(iscsi_sess_t *isp)
{
	iscsi_hba_t		*ihp;
	char			ks_name[KSTAT_STRLEN];
	iscsi_sess_stats_t	*iss;
	int			i;

	ASSERT(isp != NULL);
	ihp = isp->sess_hba;
	ASSERT(ihp != NULL);

	/*
	 * The name of the KSTAT structure is built.
	 */
	bzero(ks_name, sizeof (ks_name));

	if (snprintf(ks_name, sizeof (ks_name) - 1, iSCSI_SESS_BASE_NAME,
	    isp->sess_hba->hba_oid, isp->sess_oid) >= sizeof (ks_name)) {
		cmn_err(CE_NOTE, "iscsi kstat creation failed for "
		    "session(%u)", isp->sess_oid);
		return (TRUE);
	}

	isp->stats.ks = kstat_create(iSCSI_MODULE_NAME,
	    ddi_get_instance(ihp->hba_dip), ks_name, iSCSI_CLASS_SESS,
	    KSTAT_TYPE_NAMED, 0, KSTAT_FLAG_VIRTUAL);

	if (isp->stats.ks == NULL) {
		cmn_err(CE_NOTE, "iscsi kstat creation failed "
		    "for session(%u)", isp->sess_oid);
		return (TRUE);
	}

	iss = &isp->stats.ks_data;
	isp->stats.ks->ks_data = (void *)&isp->stats.ks_data;
	isp->stats.ks->ks_data_size = sizeof (isp->stats.ks_data);
	isp->stats.ks->ks_ndata = KN_SESS_IDX_MAX;

	for (i = 0; i < KN_SESS_IDX_MAX; i++) {
		kstat_named_init(&iss->kn[i], kstat_items_sess[i]._name,
		    kstat_items_sess[i]._data_type);
	}

	/* The static information is updated immediately */
	bzero(iss->hba_str, sizeof (iss->hba_str));
	bcopy(ihp->stats.ks->ks_name, iss->hba_str, sizeof (iss->hba_str));
	kstat_named_setstr(&iss->kn[KN_SESS_IDX_HBA],
	    (const char *)iss->hba_str);

	iss->kn[KN_SESS_IDX_OID].value.ul = isp->sess_oid;

	isp->stats.ks->ks_update = iscsi_sess_kstat_update;
	isp->stats.ks->ks_private = (void *)isp;

	/* The IO KSTAT structure is created */
	bzero(ks_name, sizeof (ks_name));

	if (snprintf(ks_name, sizeof (ks_name) - 1, iSCSI_SESS_IO_BASE_NAME,
	    isp->sess_hba->hba_oid, isp->sess_oid) >= sizeof (ks_name)) {
		cmn_err(CE_NOTE, "iscsi kstat createion failed "
		    "for session(%u)", isp->sess_oid);
		kstat_delete(isp->stats.ks);
		return (TRUE);
	}

	isp->stats.ks_io = kstat_create(iSCSI_MODULE_NAME,
	    ddi_get_instance(ihp->hba_dip), ks_name, iSCSI_CLASS_SESS,
	    KSTAT_TYPE_IO, 1, KSTAT_FLAG_VIRTUAL);

	if (isp->stats.ks_io == NULL) {
		kstat_delete(isp->stats.ks);
		cmn_err(CE_NOTE, "iscsi kstat creation failed "
		    "for session(%u)", isp->sess_oid);
		return (TRUE);
	}
	mutex_init(&isp->stats.ks_io_lock, NULL, MUTEX_DRIVER, NULL);
	isp->stats.ks_io->ks_data = &isp->stats.ks_io_data;
	isp->stats.ks_io->ks_lock = &isp->stats.ks_io_lock;

	kstat_install(isp->stats.ks);
	kstat_install(isp->stats.ks_io);

	return (FALSE);
}

/*
 * iscsi_sess_kstat_term - This function deregisters with the kstat service.
 */
boolean_t
iscsi_sess_kstat_term(iscsi_sess_t *isp)
{
	kstat_delete(isp->stats.ks_io);
	mutex_destroy(&isp->stats.ks_io_lock);
	kstat_delete(isp->stats.ks);
	return (FALSE);
}

/*
 * iscsi_sess_kstat_update - This function update the kstat
 *	structure of the HBA.
 */
int
iscsi_sess_kstat_update(kstat_t *ks, int rw)
{
	iscsi_sess_t		*isp = (iscsi_sess_t *)ks->ks_private;
	iscsi_sess_stats_t	*iss = &isp->stats.ks_data;
	char			*ptr;
	int			len;

	if (rw == KSTAT_READ) {

		/* String indicating the state of the session */
		ptr = iscsi_sess_state_str(isp->sess_state);
		len =  strlen(ptr);
		if (len > (sizeof (iss->state_str) - 1)) {
			len = sizeof (iss->state_str) - 1;
		}
		bzero(iss->state_str, sizeof (iss->state_str));
		bcopy(ptr, iss->state_str, len);
		kstat_named_setstr(
		    &iss->kn[KN_SESS_IDX_STATE],
		    (const char *)iss->state_str);

		/* Target name string */
		if (isp->sess_name_length > sizeof (iss->target_name)) {
			len = sizeof (iss->target_name);
		} else {
			len =  isp->sess_name_length;
		}
		bzero(iss->target_name, sizeof (iss->target_name));
		bcopy(isp->sess_name, iss->target_name, len);
		kstat_named_setstr(&iss->kn[KN_SESS_IDX_TARGET_NAME],
		    (const char *)iss->target_name);

		/* Target alias string */
		if (isp->sess_alias_length > sizeof (iss->target_alias)) {
			len = sizeof (iss->target_alias);
		} else {
			len =  isp->sess_alias_length;
		}
		bzero(iss->target_alias, sizeof (iss->target_alias));
		bcopy(isp->sess_alias, iss->target_alias, len);
		kstat_named_setstr(
		    &iss->kn[KN_SESS_IDX_TARGET_ALIAS],
		    (const char *)iss->target_alias);

		iss->kn[KN_SESS_IDX_CNTR_PKT_PENDING].value.ul =
		    isp->sess_queue_pending.count;
		iss->kn[KN_SESS_IDX_CMDSN].value.ul =
		    isp->sess_cmdsn;
		iss->kn[KN_SESS_IDX_EXPCMDSN].value.ul =
		    isp->sess_expcmdsn;
		iss->kn[KN_SESS_IDX_MAXCMDSN].value.ul =
		    isp->sess_maxcmdsn;
		iss->kn[KN_SESS_IDX_TPGT].value.ul =
		    isp->sess_tpgt_conf;

	}
	return (0);
}

/*
 * Connection
 */

/*
 * iscsi_conn_kstat_init - This function registers with the kstat service.
 */
boolean_t
iscsi_conn_kstat_init(iscsi_conn_t *icp)
{
	iscsi_sess_t		*isp = icp->conn_sess;
	iscsi_hba_t		*ihp = isp->sess_hba;
	iscsi_conn_stats_t	*ics;
	int			i;
	char			ks_name[KSTAT_STRLEN];

	/*
	 * The name of the KSTAT structure is built.
	 */
	bzero(ks_name, sizeof (ks_name));

	if (snprintf(ks_name, sizeof (ks_name) - 1, iSCSI_CONN_BASE_NAME,
	    icp->conn_sess->sess_hba->hba_oid, icp->conn_sess->sess_oid,
	    icp->conn_oid) >= sizeof (ks_name)) {
		return (TRUE);
	}

	icp->stats.ks = kstat_create(iSCSI_MODULE_NAME,
	    ddi_get_instance(ihp->hba_dip), ks_name, iSCSI_CLASS_CONN,
	    KSTAT_TYPE_NAMED, 0, KSTAT_FLAG_VIRTUAL);

	if (icp->stats.ks == NULL) {
		cmn_err(CE_NOTE, "iscsi kstat creation failed "
		    "for connection(%d)", icp->conn_oid);
		return (TRUE);
	}

	ics = &icp->stats.ks_data;
	icp->stats.ks->ks_data = (void *)ics;
	icp->stats.ks->ks_data_size = sizeof (*ics);
	icp->stats.ks->ks_ndata = KN_CONN_IDX_MAX;

	for (i = 0; i < KN_CONN_IDX_MAX; i++) {
		kstat_named_init(&ics->kn[i], kstat_items_conn[i]._name,
		    kstat_items_conn[i]._data_type);
	}

	/* The static information is updated immediately */
	bzero(ics->sess_str, sizeof (ics->sess_str));
	bcopy(isp->stats.ks->ks_name,
	    ics->sess_str,
	    sizeof (ics->sess_str));

	kstat_named_setstr(&ics->kn[KN_CONN_IDX_SESS],
	    (const char *)ics->sess_str);

	ics->kn[KN_CONN_IDX_OID].value.ul = isp->sess_oid;
	ics->kn[KN_CONN_IDX_CID].value.ul = icp->conn_cid;
	icp->stats.ks->ks_update = iscsi_conn_kstat_update;
	icp->stats.ks->ks_private = (void *)icp;

	kstat_install(icp->stats.ks);

	return (FALSE);
}

/*
 * iscsi_conn_kstat_term - This function deregisters with the kstat service.
 */
void
iscsi_conn_kstat_term(iscsi_conn_t *icp)
{
	kstat_delete(icp->stats.ks);
}

/*
 * iscsi_conn_kstat_update - This function update the kstat
 *	structure of the HBA.
 */
int
iscsi_conn_kstat_update(kstat_t *ks, int rw)
{
	iscsi_conn_t	*icp = (iscsi_conn_t *)ks->ks_private;
	iscsi_conn_stats_t	*ics = &icp->stats.ks_data;
	int			len;

	if (rw == KSTAT_READ) {
		len =  strlen(iscsi_ics_name[icp->conn_state]);
		if (len > (sizeof (ics->state_str) - 1)) {
			len = sizeof (ics->state_str) - 1;
		}
		bzero(ics->state_str, sizeof (ics->state_str));
		bcopy(iscsi_ics_name[icp->conn_state], ics->state_str, len);
		kstat_named_setstr(&ics->kn[KN_CONN_IDX_STATE],
		    (const char *)ics->state_str);

		ics->kn[KN_CONN_IDX_CNTR_QACTIVE].value.ul =
		    icp->conn_queue_active.count;
		ics->kn[KN_CONN_IDX_EXPSTATSN].value.ul =
		    icp->conn_expstatsn;
		ics->kn[KN_CONN_IDX_LASTSTATSN].value.ul =
		    icp->conn_laststatsn;
	}
	return (0);
}