/*
 * 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 2021 Tintri by DDN, Inc. All rights reserved.
 */

#include <sys/types.h>
#include <sys/kstat.h>
#include <sys/mdb_modapi.h>
#include <rpc/clnt.h>
#include <nfs/nfs_clnt.h>
#include <nfs/nfs4_clnt.h>

#include "svc.h"
#include "rfs4.h"
#include "nfssrv.h"
#include "common.h"

#define	NFS4_MINOR_VERS_COUNT 0
#define	NFS_STAT_NUM_STATS 79

/*
 * Structure used to group kstats we want to print.
 */
typedef struct nfs_mdb_stats {
	struct nfs_stats nfsstats;
	struct rpcstat rpcstats;
	struct nfs_globals nfsglbls;
	uintptr_t clntstat;
	uintptr_t clntstat4; /* extend this for NFS4.X */
	uintptr_t callback_stats;
} nfs_mdb_stats_t;

static int nfs_stat_clnt(nfs_mdb_stats_t *, int, int);
static int nfs_stat_srv(nfs_mdb_stats_t *, int, int);
static int nfs_srvstat(nfs_mdb_stats_t *, int);
static int nfs_srvstat_rpc(nfs_mdb_stats_t *);
static int nfs_srvstat_acl(nfs_mdb_stats_t *, int);
static int nfs_clntstat(nfs_mdb_stats_t *, int);
static int nfs_clntstat_rpc(nfs_mdb_stats_t *);
static int nfs_clntstat_acl(nfs_mdb_stats_t *, int);
static int nfs_srvstat_cb(nfs_mdb_stats_t *);

#define	NFS_SRV_STAT	0x1
#define	NFS_CLNT_STAT	0x2
#define	NFS_CB_STAT	0x4
#define	NFS_NFS_STAT	0x1
#define	NFS_ACL_STAT	0x2
#define	NFS_RPC_STAT	0x4
#define	NFS_V2_STAT	0x1
#define	NFS_V3_STAT	0x2
#define	NFS_V4_STAT	0x4

static int prt_nfs_stats(uintptr_t, char *);
static void kstat_prtout(char *, uint64_t *, int);

void
nfs_stat_help(void)
{
	mdb_printf("Switches similar to those of nfsstat command.\n",
	    "            ::nfs_stat -a	-> ACL    Statistics.\n"
	    "            ::nfs_stat -b  -> Callback Stats. (V4 only)\n"
	    "            ::nfs_stat -c  -> Client Statistics.\n"
	    "            ::nfs_stat -n	-> NFS    Statistics.\n"
	    "            ::nfs_stat -r	-> RPC    Statistics.\n"
	    "            ::nfs_stat -s	-> Server Statistics.\n"
	    "            ::nfs_stat -2	-> Version 2.\n"
	    "            ::nfs_stat -3	-> Version 3.\n"
	    "            ::nfs_stat -4	-> Version 4.\n");
}

int
nfs_stat_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int host_flag = 0; /* host or client flag */
	int type_flag = 0; /* type acl, rpc of nfs */
	int vers_flag = 0; /* NFS version flag */
	nfs_mdb_stats_t mdb_stats;
	uintptr_t glbls;
	uintptr_t cb_glbls;
	uintptr_t zonep;

	if (argc == 1 && argv->a_type == MDB_TYPE_IMMEDIATE) {
		kstat_named_t ksts;
		int i;
		for (i = argv->a_un.a_val; i; i--) {
			if (mdb_vread(&ksts, sizeof (ksts), addr) < 0) {
				mdb_warn("failed to read kstat_name_t");
				return (DCMD_ERR);
			}
			mdb_printf(" %8s %30d\n", ksts.name, ksts.value.ui64);
			addr += sizeof (ksts);
		}
		return (DCMD_OK);
	}

	if (mdb_getopts(argc, argv,
	    'a', MDB_OPT_SETBITS, NFS_ACL_STAT, &type_flag,
	    'b', MDB_OPT_SETBITS, NFS_CB_STAT, &host_flag,
	    'c', MDB_OPT_SETBITS, NFS_CLNT_STAT, &host_flag,
	    'n', MDB_OPT_SETBITS, NFS_NFS_STAT, &type_flag,
	    'r', MDB_OPT_SETBITS, NFS_RPC_STAT, &type_flag,
	    's', MDB_OPT_SETBITS, NFS_SRV_STAT, &host_flag,
	    '2', MDB_OPT_SETBITS, NFS_V2_STAT, &vers_flag,
	    '3', MDB_OPT_SETBITS, NFS_V3_STAT, &vers_flag,
	    '4', MDB_OPT_SETBITS, NFS_V4_STAT, &vers_flag,
	    NULL) != argc) {
		return (DCMD_USAGE);
	}


	if (flags & DCMD_ADDRSPEC) {
		zonep = addr;
	} else {
		if (mdb_readsym(&zonep, sizeof (uintptr_t),
		    "global_zone") == -1) {
			mdb_warn("Failed to find global_zone");
			return (DCMD_ERR);
		}
	}

	if (zoned_get_zsd(zonep, "nfssrv_zone_key", &glbls)) {
		mdb_warn("Failed to find nfssrv_zone_key");
		return (DCMD_ERR);
	}

	if (mdb_vread(&mdb_stats.nfsglbls, sizeof (struct nfs_globals),
	    glbls) == -1) {
		mdb_warn("Failed to read nfs_stats at %p", glbls);
		return (DCMD_ERR);
	}

	if (zoned_get_zsd(zonep, "nfsstat_zone_key", &glbls)) {
		mdb_warn("Failed to find %s", "nfsstat_zone_key");
		return (DCMD_ERR);
	}

	if (mdb_vread(&mdb_stats.nfsstats, sizeof (struct nfs_stats),
	    glbls) == -1) {
		mdb_warn("Failed to read nfs_stats at %p", glbls);
		return (DCMD_ERR);
	}

	if (zoned_get_zsd(zonep, "rpcstat_zone_key", &glbls)) {
		mdb_warn("Failed to find %s", "rpcstat_zone_key");
		return (DCMD_ERR);
	}

	if (mdb_vread(&mdb_stats.rpcstats, sizeof (struct rpcstat),
	    glbls) == -1) {
		mdb_warn("Failed to read nfs_stats at %p", glbls);
		return (DCMD_ERR);
	}

	if (zoned_get_zsd(zonep, "nfsclnt_zone_key", &glbls)) {
		mdb_warn("Failed to find %s", "nfsclnt_zone_key");
		return (DCMD_ERR);
	}
	mdb_stats.clntstat = glbls + offsetof(struct nfs_clnt, nfscl_stat);

	if (zoned_get_zsd(zonep, "nfs4clnt_zone_key", &glbls)) {
		mdb_warn("Failed to find %s", "nfs4clnt_zone_key");
		return (DCMD_ERR);
	}
	/*
	 * currently only have NFSv4.0 is availble. When NFSv4.1 and above are
	 * available stats support will need to be added.
	 */
	mdb_stats.clntstat4 = glbls + offsetof(struct nfs4_clnt, nfscl_stat);

	if (zoned_get_zsd(zonep, "nfs4_callback_zone_key",
	    (uintptr_t *)&cb_glbls)) {
		mdb_warn("Failed to find %s", "nfs4_callback_zone_key");
		return (DCMD_ERR);
	}

	mdb_stats.callback_stats =
	    (cb_glbls + offsetof(struct nfs4_callback_globals,
	    nfs4_callback_stats));

	if (host_flag == 0)
		host_flag = NFS_SRV_STAT | NFS_CLNT_STAT | NFS_CB_STAT;
	if (vers_flag == 0)
		vers_flag = NFS_V2_STAT | NFS_V3_STAT | NFS_V4_STAT;
	if (type_flag == 0)
		type_flag = NFS_NFS_STAT | NFS_ACL_STAT | NFS_RPC_STAT;

	if (host_flag & NFS_CB_STAT)
		if (nfs_srvstat_cb(&mdb_stats))
			return (DCMD_ERR);
	if (host_flag & NFS_SRV_STAT)
		if (nfs_stat_srv(&mdb_stats, type_flag, vers_flag))
			return (DCMD_ERR);
	if (host_flag & NFS_CLNT_STAT)
		if (nfs_stat_clnt(&mdb_stats, type_flag, vers_flag))
			return (DCMD_ERR);
	return (DCMD_OK);
}

static int
nfs_srvstat_cb(nfs_mdb_stats_t *stptr)
{
	int ret = 0;
	mdb_printf("CALLBACK STATISTICS:\n");

	ret = prt_nfs_stats(stptr->callback_stats, "nfs4_callback_stats_tmpl");

	return (ret);
}

static int
nfs_stat_srv(nfs_mdb_stats_t *stptr, int type_flag, int vers_flag)
{
	mdb_printf("NFS SERVER STATS:\n");
	if (type_flag & NFS_SRV_STAT) {
		if (nfs_srvstat(stptr, vers_flag) != 0)
			return (1);
	}
	if (type_flag & NFS_RPC_STAT) {
		if (nfs_srvstat_rpc(stptr) != 0)
			return (1);
	}
	if (type_flag & NFS_ACL_STAT) {
		if (nfs_srvstat_acl(stptr, vers_flag) != 0)
			return (1);
	}
	return (0);
}

static int
nfs_stat_clnt(nfs_mdb_stats_t *stptr, int type_flag, int vers_flag)
{
	mdb_printf("CLIENT STATISTICS:\n");
	if (type_flag & NFS_CLNT_STAT) {
		if (nfs_clntstat(stptr, vers_flag))
			return (1);
	}
	if (type_flag & NFS_ACL_STAT) {
		if (nfs_clntstat_acl(stptr, vers_flag))
			return (1);
	}
	if (type_flag & NFS_RPC_STAT) {
		if (nfs_clntstat_rpc(stptr))
			return (1);
	}
	return (0);
}


static int
nfs_srvstat(nfs_mdb_stats_t *stptr, int flag)
{
	mdb_printf("NFS Statistics\n");
	if (flag & NFS_V2_STAT) {
		mdb_printf("NFSv2\n");
		if (prt_nfs_stats((uintptr_t)stptr->nfsglbls.svstat[2],
		    "svstat_tmpl") ||
		    prt_nfs_stats((uintptr_t)stptr->nfsglbls.rfsproccnt[2],
		    "rfsproccnt_v2_tmpl"))
			return (-1);
	}
	if (flag & NFS_V3_STAT) {
		mdb_printf("NFSv3\n");
		if (prt_nfs_stats((uintptr_t)stptr->nfsglbls.svstat[3],
		    "svstat_tmpl") ||
		    prt_nfs_stats((uintptr_t)stptr->nfsglbls.rfsproccnt[3],
		    "rfsproccnt_v3_tmpl"))
			return (-1);
	}
	if (flag & NFS_V4_STAT) {
		mdb_printf("NFSv4\n");
		if (prt_nfs_stats((uintptr_t)stptr->nfsglbls.svstat[4],
		    "svstat_tmpl") ||
		    prt_nfs_stats((uintptr_t)stptr->nfsglbls.rfsproccnt[4],
		    "rfsproccnt_v4_tmpl"))
			return (-1);
	}
	return (0);
}


static int
nfs_srvstat_rpc(nfs_mdb_stats_t *stptr)
{
	mdb_printf("NFS RPC Statistics\n");
	mdb_printf("ConnectionLess\n");
	if (prt_nfs_stats((uintptr_t)stptr->rpcstats.rpc_clts_server,
	    "clts_rsstat_tmpl"))
		return (-1);
	mdb_printf("ConnectionOriented\n");
	if (prt_nfs_stats((uintptr_t)stptr->rpcstats.rpc_cots_server,
	    "cots_rsstat_tmpl"))
		return (-1);
	return (0);
}


static int
nfs_srvstat_acl(nfs_mdb_stats_t *stptr, int flags)
{
	mdb_printf("NFS ACL Statistics\n");
	if (flags & NFS_V2_STAT) {
		mdb_printf("NFSv2\n");
		if (prt_nfs_stats((uintptr_t)stptr->nfsglbls.aclproccnt[2],
		    "aclproccnt_v2_tmpl"))
			return (-1);
	}
	if (flags & NFS_V3_STAT) {
		mdb_printf("NFSv3\n");
		if (prt_nfs_stats((uintptr_t)stptr->nfsglbls.aclproccnt[3],
		    "aclproccnt_v3_tmpl"))
			return (-1);
	}
	if (flags & NFS_V4_STAT) {
		mdb_printf("NFSv4\n");
		if (prt_nfs_stats((uintptr_t)stptr->nfsglbls.aclproccnt[4],
		    "aclreqcnt_v4_tmpl"))
			return (-1);
	}
	return (0);
}

static int
nfs_clntstat(nfs_mdb_stats_t *stptr, int flags)
{
	mdb_printf("NFS Statistics\n");
	if (prt_nfs_stats((uintptr_t)stptr->clntstat, "clstat_tmpl"))
		return (-1);
	if (flags & NFS_V2_STAT) {
		mdb_printf("Version 2\n");
		if (prt_nfs_stats(
		    (uintptr_t)stptr->nfsstats.nfs_stats_v2.rfsreqcnt_ptr,
		    "rfsreqcnt_v2_tmpl"))
			return (-1);
	}
	if (flags & NFS_V3_STAT) {
		mdb_printf("Version 3\n");
		if (prt_nfs_stats(
		    (uintptr_t)stptr->nfsstats.nfs_stats_v3.rfsreqcnt_ptr,
		    "rfsreqcnt_v3_tmpl"))
			return (-1);
	}
	if (flags & NFS_V4_STAT) {
		mdb_printf("NFSv4 client\n");
		if (prt_nfs_stats((uintptr_t)stptr->clntstat, "clstat4_tmpl"))
			return (-1);
		mdb_printf("Version 4\n");
		if (prt_nfs_stats(
		    (uintptr_t)stptr->nfsstats.nfs_stats_v4.rfsreqcnt_ptr,
		    "rfsreqcnt_v4_tmpl"))
			return (-1);
	}
	return (0);
}

static int
nfs_clntstat_rpc(nfs_mdb_stats_t *stptr)
{
	mdb_printf("NFS RPC Statistics\n");
	mdb_printf("ConnectionLess\n");
	if (prt_nfs_stats((uintptr_t)stptr->rpcstats.rpc_clts_client,
	    "clts_rcstat_tmpl"))
		return (-1);
	mdb_printf("ConnectionOriented\n");
	if (prt_nfs_stats((uintptr_t)stptr->rpcstats.rpc_cots_client,
	    "cots_rcstat_tmpl"))
		return (-1);
	return (0);
}

static int
nfs_clntstat_acl(nfs_mdb_stats_t *stptr, int flags)
{
	mdb_printf("ACL Statistics\n");
	if (flags & NFS_V2_STAT) {
		mdb_printf("Version 2\n");
		if (prt_nfs_stats(
		    (uintptr_t)stptr->nfsstats.nfs_stats_v2.aclreqcnt_ptr,
		    "aclreqcnt_v2_tmpl"))
			return (-1);
	}
	if (flags & NFS_V3_STAT) {
		mdb_printf("Version 3\n");
		if (prt_nfs_stats(
		    (uintptr_t)stptr->nfsstats.nfs_stats_v3.aclreqcnt_ptr,
		    "aclreqcnt_v3_tmpl"))
			return (-1);
	}
	if (flags & NFS_V4_STAT) {
		mdb_printf("Version 4\n");
		if (prt_nfs_stats(
		    (uintptr_t)stptr->nfsstats.nfs_stats_v4.aclreqcnt_ptr,
		    "aclreqcnt_v4_tmpl"))
			return (-1);
	}
	return (0);
}


/*
 * helper functions for printing out the kstat data
 */

#define	NFS_STAT_NUM_CLMNS 16

static int
prt_nfs_stats(uintptr_t addr, char *name)
{

	GElf_Sym sym;
	kstat_named_t kstats;
	char *kstat_line;
	uint64_t *value;
	uint_t count;
	int i = 0, status = 0;


	if (mdb_lookup_by_name(name, &sym) != 0) {
		mdb_warn("failed to find %s", name);
		return (1);
	}

	count = sym.st_size / sizeof (kstat_named_t);

	kstat_line = mdb_alloc(count * NFS_STAT_NUM_CLMNS, UM_SLEEP);
	value = mdb_alloc(count * sizeof (uint64_t), UM_SLEEP);
	for (i = 0; i < count; i++) {
		if (mdb_vread(&kstats, sizeof (kstat_named_t),
		    addr + (i * sizeof (kstat_named_t))) < 0) {
			status = 1;
			goto done;
		}
		mdb_snprintf(&kstat_line[NFS_STAT_NUM_CLMNS * i],
		    NFS_STAT_NUM_CLMNS, "%s", kstats.name);
		value[i] = kstats.value.ui64;
	}
	kstat_prtout(kstat_line, value, count);
done:
	mdb_free(kstat_line, count * NFS_STAT_NUM_CLMNS);
	mdb_free(value, count * sizeof (uint64_t));
	return (status);
}

static void
kstat_prtout(char *ks_line, uint64_t *values, int count)
{
	char val_str[32];
	int i = 0, num = 0;

	while (i < count) {
		mdb_printf("%-*s", NFS_STAT_NUM_CLMNS,
		    &ks_line[NFS_STAT_NUM_CLMNS * i]);

		num++;
		if (num == NFS_STAT_NUM_STATS / NFS_STAT_NUM_CLMNS) {
			mdb_printf("\n");
			while (num > 0) {
				mdb_snprintf(val_str, 24, "%ld  ",
				    values[i+1-num]);
				mdb_printf("%-*s", NFS_STAT_NUM_CLMNS, val_str);
				--num;
			}
			mdb_printf("\n");
		}
		i++;
	}
	mdb_printf("\n");
}