/*
 * 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.
 */

/*
 * poolstat - report active pool statistics
 */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <unistd.h>
#include <locale.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <errno.h>
#include <stddef.h>

#include <pool.h>
#include "utils.h"
#include "poolstat.h"
#include "poolstat_utils.h"
#include "statcommon.h"

#ifndef	TEXT_DOMAIN
#define	TEXT_DOMAIN	"SYS_TEST"
#endif

#define	addrof(s)  ((char **)&(s))

/* verify if a field is printable in respect of the current option flags */
#define	PRINTABLE(i)	((lf->plf_ffs[(i)].pff_prt & D_FIELD) || \
	(lf->plf_ffs[(i)].pff_prt & X_FIELD))

typedef int (* formatter) (char *, int, int, poolstat_field_format_t *, char *);

static uint_t timestamp_fmt = NODATE;

/* available field formatters	*/
static int default_f(char *, int, int, poolstat_field_format_t *, char *);
static int bigno_f(char *, int, int, poolstat_field_format_t *, char *);
static int used_stat_f(char *, int, int, poolstat_field_format_t *, char *);
static int header_f(char *, int, int, poolstat_field_format_t *, char *);

/* statistics bags used to collect data from various provider	*/
static statistic_bag_t 	pool_sbag_s;
static statistic_bag_t 	pset_sbag_s;
static statistic_bag_t 	*pool_sbag = &pool_sbag_s;
static statistic_bag_t 	*pset_sbag = &pset_sbag_s;

/* formatter objects for pset, defined in a default printing sequence	*/
static poolstat_field_format_t pset_ffs[] = {
	/* prt flags,name,header,type,width,minwidth,offset,formatter	*/
	{ DX_FIELD, "id", "id", LL, 3, 1, addrof(pool_sbag),
		offsetof(statistic_bag_t, sb_sysid),
		(formatter)default_f },
	{ DX_FIELD, "pool", "pool", STR, 20, 14, addrof(pool_sbag),
		offsetof(statistic_bag_t, sb_name),
		(formatter)default_f },
	{ DX_FIELD, "type", "type", STR, 4, 5, addrof(pset_sbag),
		offsetof(statistic_bag_t, sb_type),
		(formatter)default_f },
	{ D_FIELD, "rid", "rid", LL, 3, 1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_sysid),
		(formatter)default_f },
	{ DX_FIELD, "rset", "rset", STR, 20, 14, addrof(pset_sbag),
		offsetof(statistic_bag_t, sb_name),
		(formatter)default_f },
	{ DX_FIELD, "min", "min", ULL, 4, 1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_min),
		(formatter)bigno_f },
	{ DX_FIELD, "max", "max", ULL, 4, 1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_max),
		(formatter)bigno_f },
	{ DX_FIELD, "size", "size", ULL, 4, 1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_size),
		(formatter)default_f },
	{ DX_FIELD, "used", "used", FL, 4, -1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_used),
		(formatter)used_stat_f },
	{ DX_FIELD, "load", "load", FL, 4, -1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_load),
		(formatter)default_f }
};

/* formatter objects for pool, defined in a default printing sequence	*/
static poolstat_field_format_t pool_ffs[] = {
	/* prt flags,name,header,type,width,minwidth,offset,formatter	*/
	{ D_FIELD, "id", "id", LL, 3, 1, addrof(pool_sbag),
		offsetof(statistic_bag_t, sb_sysid),
		(formatter)default_f },
	{ D_FIELD, "pool", "pool", STR, 20, 13, addrof(pool_sbag),
		offsetof(statistic_bag_t, sb_name),
		(formatter)default_f },
	{ D_FIELD, "p_size", "size", ULL, 4, 1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_size),
		(formatter)default_f },
	{ D_FIELD, "p_used", "used", FL, 4, -1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_used),
		(formatter)default_f },
	{ D_FIELD, "p_load", "load", FL, 4, -1, addrof(pset_sbag_s.bag),
		offsetof(pset_statistic_bag_t, pset_sb_load),
		(formatter)default_f },
};

/* lists with formatter objects, one for each statistics field */
static poolstat_line_format_t   pool_lf; /* formatting list in default mode */
static poolstat_line_format_t   pset_lf; /* formatting list for psets    */

/* name of pools to be shown */
static poolstat_list_element_t	*pnames;
/*
 * type of resources to be shown, currently we only have one type 'pset'
 * but, poolstat can be extended to handle new upcoming resource types.
 */
static poolstat_list_element_t   *rtypes;

/* a handle to the pool configuration	*/
static pool_conf_t *conf;

/* option flags		*/
static int 	rflag;
static int 	pflag;
static int 	oflag;

/* operands	*/
static int 	interval = 0;	/* update interval	*/
static long 	count    = 1; 	/* one run		*/

/* data structure handlers	*/
static poolstat_list_element_t *
	create_prt_sequence_list(char *, poolstat_line_format_t *);
static poolstat_list_element_t *
	create_args_list(char *, poolstat_list_element_t *, const char *);

/* statistics update function	*/
static void sa_update(statistic_bag_t *, int);

/* statistics printing function	*/
static void prt_pool_stats(poolstat_list_element_t *);

static void usage(void) __NORETURN;

static void
usage(void)
{
	(void) fprintf(stderr, gettext(
"Usage:\n"
"poolstat [-p pool-list] [-r rset-list] [-T d|u] [interval [count]]\n"
"poolstat [-p pool-list] [-o format -r rset-list] [-T d|u] [interval [count]]\n"
"  \'pool-list\' is a space-separated list of pool IDs or names\n"
"  \'rset-list\' is \'all\' or \'pset\'\n"
"  \'format\' for all resource types is one or more of:\n"
"\tid pool type rid rset min max size used load\n"));
	(void) exit(E_USAGE);
}

static int
Atoi(char *p, int *errp)
{
	int i;
	char *q;
	errno = 0;
	i = strtol(p, &q, 10);
	if (errno != 0 || q == p || *q != '\0')
		*errp = -1;
	else
		*errp = 0;
	return (i);
}

int
main(int argc, char *argv[])
{
	int		c;
	int 		error = 0;

	(void) getpname(argv[0]);
	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	/* pset_sbag_s is used to collect pset statistics   */
	pset_sbag_s.sb_type = PSET_TYPE_NAME;
	pset_sbag_s.bag	= ZALLOC(sizeof (pset_statistic_bag_t));
	pool_sbag_s.sb_type = POOL_TYPE_NAME;

	pset_lf.plf_ffs = pset_ffs;
	pset_lf.plf_ff_len = sizeof (pset_ffs) /
	    sizeof (poolstat_field_format_t);
	pool_lf.plf_ffs = pool_ffs;
	pool_lf.plf_ff_len = sizeof (pool_ffs) /
	    sizeof (poolstat_field_format_t);

	/* Don't let buffering interfere with piped output. */
	(void) setvbuf(stdout, NULL, _IOLBF, 0);

	while ((c = getopt(argc, argv, ":p:r:o:T:")) != EOF) {
		switch (c) {
		case 'p':	/* pool name specification	*/
			pflag++;
			pnames = create_args_list(optarg, pnames,
			    " \t");
			break;
		case 'r': {	/* resource type 		*/
			rflag++;
			rtypes = create_args_list(optarg, rtypes,
			    " \t,");
			break;
			}
		case 'o': { 	/* format specification		*/
			oflag++;
			if (create_prt_sequence_list(optarg, &pset_lf) == NULL)
				usage();
			break;
			}
		case 'T':
			if (optarg) {
				if (*optarg == 'u')
					timestamp_fmt = UDATE;
				else if (*optarg == 'd')
					timestamp_fmt = DDATE;
				else
					usage();
			} else {
					usage();
			}
			break;
		case ':': {
			(void) fprintf(stderr,
			    gettext(ERR_OPTION_ARGS), optopt);
			usage();
			/*NOTREACHED*/
			}
		default:
			(void) fprintf(stderr, gettext(ERR_OPTION), optopt);
			usage();
			/*NOTREACHED*/
		}
	}

	/* get operands	*/
	if (argc > optind) {
		if ((interval = Atoi(argv[optind++], &error)) < 1 || error != 0)
			usage();
		count = -1;
	}
	if (argc > optind) {
		if ((count = Atoi(argv[optind++], &error)) < 1 || error != 0)
			usage();
	}
	/* check for extra options/operands	*/
	if (argc > optind)
		usage();

	/* check options	*/
	if (oflag && !rflag)
		usage();

	/* global initializations	*/
	if (!oflag) {
		/* create the default print sequences	*/
		(void) create_prt_sequence_list(NULL, &pool_lf);
		(void) create_prt_sequence_list(NULL, &pset_lf);
	}

	if (rtypes == NULL || strcmp(rtypes->ple_obj, "all") == 0) {
		/* crate a default resource list	*/
		FREE(rtypes);
		rtypes = create_args_list("pset", NULL, " \t,");
	}

	if ((conf = pool_conf_alloc()) == NULL)
		die(gettext(ERR_NOMEM));
	if (pool_conf_open(conf, pool_dynamic_location(), PO_RDONLY)
	    != PO_SUCCESS)
		die(gettext(ERR_OPEN_DYNAMIC), get_errstr());

	/* initialize statistic adapters	*/
	sa_libpool_init(conf);
	sa_kstat_init(NULL);

	/* collect and print out statistics	*/
	while (count-- != 0) {
		sa_update(pool_sbag, SA_REFRESH);
		if (timestamp_fmt != NODATE)
			print_timestamp(timestamp_fmt);
		if (pool_sbag->sb_changed & POU_POOL)
				(void) printf(
				"<<State change>>\n");
		prt_pool_stats(pnames);
		if (count != 0) {
			(void) sleep(interval);
			if (rflag)
				(void) printf("\n");
		}
	}

	return (E_PO_SUCCESS);
}

/*
 * Take the arguments and create/append a string list to the 'le' list.
 */
static poolstat_list_element_t  *
create_args_list(char *arg, poolstat_list_element_t  *le, const char *delim)
{
	poolstat_list_element_t *head = le;

	while (arg != NULL && *arg != '\0') {
		char *name = arg;
		arg = strpbrk(arg, delim);
		if (arg != NULL) {
			*arg++ = '\0';
		}
		if (le == NULL) {
			/* create first element */
			NEW0(le);
			head = le;
		} else {
			/* find last and append	*/
			while (le->ple_next != NULL)
				le = le->ple_next;
			NEW0(le->ple_next);
			le = le->ple_next;
		}
		le->ple_obj = (void *)name;
	}

	return (head);
}

/*
 * Take the arguments to the -o option, and create a format field list in order
 * specified by 'arg'.
 * If 'arg' is NULL a list in a default printing order is created.
 */
static poolstat_list_element_t *
create_prt_sequence_list(char *arg, poolstat_line_format_t *lf)
{
	/*
	 * Create a default print sequence. It is the sequence defined
	 * statically in the format list. At the same time mark the fields
	 * printable according to the current option settings.
	 */
	if (arg == NULL) {
		int	i;
		NEW0(lf->plf_prt_seq);
		lf->plf_ffs[0].pff_prt |= PRINTABLE(0) ? PABLE_FIELD : 0;
		lf->plf_last = lf->plf_prt_seq;
		lf->plf_last->ple_obj = &(lf->plf_ffs[0]);
		for (i = 1; i < lf->plf_ff_len; i++) {
			lf->plf_ffs[i].pff_prt |=
			    PRINTABLE(i) ? PABLE_FIELD : 0;
			NEW0(lf->plf_last->ple_next);
			lf->plf_last = lf->plf_last->ple_next;
			lf->plf_last->ple_obj = &(lf->plf_ffs[i]);
		}
		return (lf->plf_prt_seq);
	}

	while (arg != NULL && *arg != '\0') {
		poolstat_field_format_t *ff;	/* current format field */
		int 	ffIdx;	/* format field index	    */
		char 	*name;	/* name of field	    */
		int	n; 	/* no. of chars to strip    */

		n = strspn(arg, " ,\t\r\v\f\n");
		arg += n;	/* strip multiples separator	*/
		name = arg;

		if (strlen(name) < 1)
			break;

		if ((arg = strpbrk(arg, " ,\t\r\v\f\n")) != NULL)
			*arg++ = '\0';

		/* search for a named format field */
		for (ffIdx = 0; ffIdx < lf->plf_ff_len; ffIdx++) {
			ff = lf->plf_ffs + ffIdx;
			if (strcmp(ff->pff_name, name) == 0) {
				ff->pff_prt |= PABLE_FIELD;
				break;
			}
		}
		/* if the name wasn't found	*/
		if (ffIdx == lf->plf_ff_len) {
			(void) fprintf(stderr, gettext(ERR_UNSUPP_STAT_FIELD),
			    name);
			usage();
		}
		if (lf->plf_last == NULL) {
			/* create first print handle */
			NEW0(lf->plf_prt_seq);
			lf->plf_last = lf->plf_prt_seq;
		} else {
			NEW0(lf->plf_last->ple_next);
			lf->plf_last = lf->plf_last->ple_next;
		}
		lf->plf_last->ple_obj = ff; 	/* refer to the format field */
	}

	return (lf->plf_prt_seq);
}

/* update the statistic data by adapters	*/
static void
sa_update(statistic_bag_t *sbag, int flags)
{
	sa_libpool_update(sbag, flags);
	sa_kstat_update(sbag, flags);
}

/*
 * Format one statistic field and put it into the 'str' buffer. 'ff' contains
 * the field formatting parameters. Return the number of used bytes.
 */
static int
default_f(char *str, int pos, int left, poolstat_field_format_t *ff, char *data)
{
	int  used;

	switch (ff->pff_type) {
	case LL: {
			int64_t v;
			v = *((int64_t *)(void *)(data + ff->pff_offset));
			used = snprintf(str + pos, left, "%*.*lld",
			    ff->pff_width, ff->pff_minwidth, v);
		}
		break;
	case ULL: {
			uint64_t v;
			v = *((uint64_t *)(void *)(data + ff->pff_offset));
			used = snprintf(str + pos, left, "%*.*llu",
			    ff->pff_width, ff->pff_minwidth, v);
		};
		break;
	case FL: {
			int	pw = 0;
			double v = *((double *)(void *)(data + ff->pff_offset));
			if (v < 10) {
				pw = ff->pff_width - 2;
			} else if (v < 100) {
				pw = ff->pff_width - 3;
			} else if (v < 1000) {
				pw = ff->pff_width - 4;
			}
			if (pw < 0)
				pw = 0;
			used = snprintf(str + pos, left, "%*.*f",
			    ff->pff_width, pw, v);
		};
		break;
	case STR: {
			char 	*v;
			int 	sl;
			v = *((char **)(void *)(data + ff->pff_offset));
			sl = strlen(v);
			/* truncate if it doesn't fit	*/
			if (sl > ff->pff_width) {
				char *cp = v +  ff->pff_width - 1;
				if (ff->pff_width < 4)
					die(gettext(ERR_STATS_FORMAT),
					    ff->pff_header);
				*cp-- = 0;
				*cp-- = '.';
				*cp-- = '.';
				*cp-- = '.';
			}
			used = snprintf(str + pos, left, "%-*s", ff->pff_width,
			    v);
		}
		break;
	}

	return (used);
}

/* format big numbers */
static int
bigno_f(char *str, int pos, int left, poolstat_field_format_t *ff, char *data)
{
	uint64_t v;
	char	tag;
	int	pw = ff->pff_width - 4;
	double 	pv;
	int  	used;

	v = *((uint64_t *)(void *)(data + ff->pff_offset));
	/*
	 * the max value can be ULONG_MAX, which is formatted as:
	 * E  P   T   G   M   K
	 * 18 446 744 073 709 551 615
	 * As a result ULONG_MAX is displayed as 18E
	 */
	pv = v;
	if (v < 1000) {
		pw = 0;
	} else if (v < KILO * 10) {
		pv = (double)v / KILO;
		tag = 'K';
	} else if (v < KILO * 100) {
		pv = (double)v / KILO;
		tag = 'K'; pw -= 1;
	} else if (v < KILO * 1000) {
		pv = (double)v / KILO;
		tag = 'K'; pw -= 2;
	} else if (v < MEGA * 10) {
		pv = (double)v / MEGA;
		tag = 'M';
	} else if (v < MEGA * 100) {
		pv = (double)v / MEGA;
		tag = 'M'; pw -= 1;
	} else if (v < MEGA * 1000) {
		pv = (double)v / MEGA;
		tag = 'M'; pw -= 2;
	} else if (v < GIGA * 10) {
		pv = (double)v / GIGA;
		tag = 'G';
	} else if (v < GIGA * 100) {
		pv = (double)v / GIGA;
		tag = 'G'; pw -= 1;
	} else if (v < GIGA * 1000) {
		pv = (double)v / GIGA;
		tag = 'G'; pw -= 2;
	} else if (v < TERA * 10) {
		pv = (double)v / TERA;
		tag = 'T';
	} else if (v < TERA * 100) {
		pv = (double)v / TERA;
		tag = 'T'; pw -= 1;
	} else if (v < TERA * 1000) {
		pv = (double)v / TERA;
		tag = 'T'; pw -= 2;
	} else if (v < PETA * 10) {
		pv = (double)v / PETA;
		tag = 'P';
	} else if (v < PETA * 100) {
		pv = (double)v / PETA;
		tag = 'P'; pw -= 1;
	} else if (v < PETA * 1000) {
		pv = (double)v / PETA;
		tag = 'P'; pw -= 2;
	} else if (v < EXA * 10) {
		pv = (double)v / EXA;
		tag = 'E';
	} else if (v < EXA * 100) {
		pv = (double)v / EXA;
		tag = 'E'; pw -= 1;
	} else {
		pv = (double)v / EXA;
		tag = 'E'; pw -= 2;
	}
	if (pw < 0)
		pw = 0;
	if (v < 1000)
		used = snprintf(str + pos, left, "%*.*f",
		    ff->pff_width, pw, pv);
	else
		used = snprintf(str + pos, left, "%*.*f%c",
		    ff->pff_width - 1, pw, pv, tag);

	return (used);
}

/* format usage statistic, if configuration has changed print '-'. */
static int
used_stat_f(char *str, int pos, int left, poolstat_field_format_t *ff,
	char *data)
{
	int	pw = 0;
	double v = *((double *)(void *)(data + ff->pff_offset));
	int  	used;

	if (pool_sbag->sb_changed & POU_POOL) {
		used = snprintf(str + pos, left, "%*c", ff->pff_width, '-');
	} else {
		if (v < 10) {
			pw = ff->pff_width - 2;
		} else if (v < 100) {
			pw = ff->pff_width - 3;
		} else if (v < 1000) {
			pw = ff->pff_width - 4;
		}
		if (pw < 0)
			pw = 0;
		used = snprintf(str + pos, left, "%*.*f",
		    ff->pff_width, pw, v);
	}
	return (used);
}

/*
 * Format one header field and put it into the 'str' buffer.
 */
/*ARGSUSED*/
static int
header_f(char *str, int pos, int left, poolstat_field_format_t *ff, char *data)
{
	int  used = 0;

	if (ff->pff_type == STR)
		/* strings are left justified	*/
		used = snprintf(str + pos, left, "%-*s",
		    ff->pff_width, ff->pff_header);
	else
		used = snprintf(str + pos, left, "%*s",
		    ff->pff_width, ff->pff_header);
	return (used);
}

/*
 * Print one statistic line according to the definitions in 'lf'.
 */
static void
prt_stat_line(poolstat_line_format_t *lf)
{
	poolstat_list_element_t *le; 	/* list element in the print sequence */
	char 	*line;
	int 	pos	= 0;		/* position in the printed line	*/
	int 	len 	= MAXLINE;	/* the length of the line	*/
	int	left 	= len;		/* chars left to use in the line */

	line = ZALLOC(len);
	for (le = lf->plf_prt_seq; le; le = le->ple_next) {
		int used;
		poolstat_field_format_t *ff =
		    (poolstat_field_format_t *)le->ple_obj;
		/* if the filed is marked to be printed	*/
		if (ff->pff_prt & PABLE_FIELD) {
			if (((used = ff->pff_format(line, pos, left, ff,
			    *ff->pff_data_ptr)) + 1) >= left) {
				/* if field doesn't fit allocate new space */
				len += used + MAXLINE;
				left += used + MAXLINE;
				line = REALLOC(line, len);
				if (((used = ff->pff_format(line, pos, left, ff,
				    *ff->pff_data_ptr)) + 1) >= left)
					die(gettext(ERR_STATS_FORMAT), line);
			}
			left -= used;
			pos += used;
			if (le->ple_next != NULL) {
				/* separate columns with a space */
				line[pos++] = ' ';
				left--;
			}
		}
	}

	(void) printf("%s\n", line);
	FREE(line);
}

/*
 * Print a statistics header line for a given resource type.
 */
static void
prt_stat_hd(const char *type)
{
	poolstat_line_format_t	*lf;	/* line format	*/
	poolstat_list_element_t *le; 	/* list element in the print sequence */
	char 	*line;
	int 	pos	= 0;		/* position in the printed line	 */
	int 	len 	= MAXLINE;	/* the length of the line	 */
	int	left 	= len;		/* chars left to use in the line */

	if (strcmp(type, POOL_TYPE_NAME) == 0) {
		/* pool format needs an extra header	*/
		(void) printf("%*s\n", 19 + 15, "pset");
		lf = &pool_lf;
	} else if (strcmp(type, PSET_TYPE_NAME) == 0) {
		lf = &pset_lf;
	} else {
		die(gettext(ERR_UNSUPP_RTYPE), type);
	}
	line = ZALLOC(len);
	for (le = lf->plf_prt_seq; le; le = le->ple_next) {
		int used;	/* used chars in line	*/
		poolstat_field_format_t *ff =
		    (poolstat_field_format_t *)le->ple_obj;
		/* if the filed is marked to be printed	*/
		if (ff->pff_prt& PABLE_FIELD) {
			if (((used = header_f(line, pos, left, ff, NULL)) + 1)
			    >= left) {
				/* if field doesn't fit allocate new space */
				len += used + MAXLINE;
				left += used + MAXLINE;
				line = REALLOC(line, len);
				if (((used = header_f(line, pos, left, ff,
				    NULL)) + 1) >= left)
					die(gettext(ERR_STATS_FORMAT), line);
			}
			left -= used;
			pos += used;
			if (le->ple_next != NULL) {
				/* separate columns with a space */
				line[pos++] = ' ';
				left--;
			}
		}
	}

	/* only header line with non space characters should be printed */
	pos = 0;
	while (*(line + pos) != '\n') {
		if (!isspace(*(line + pos))) {
			(void) printf("%s\n", line);

			break;
		}
		pos++;
	}
	FREE(line);
}

/*
 * Create a pool value instance and set its name to 'name'.
 */
static pool_value_t *
create_pool_value(const char *name)
{
	pool_value_t *pval;

	if ((pval = pool_value_alloc()) == NULL) {
		return (NULL);
	}
	if (pool_value_set_name(pval, name) != PO_SUCCESS) {
		pool_value_free(pval);
		return (NULL);
	}

	return (pval);
}

/*
 * Find all resources of type 'rtype'.
 * If 'pool_name' is defined find all resources bound to this pool.
 */
static pool_resource_t **
get_resources(const char *pool_name, const char *rtype, uint_t *nelem)
{
	pool_resource_t **resources = NULL;
	pool_value_t 	*pvals[] = { NULL, NULL, NULL};
	pool_value_t 	*pv_sys_id;
	pool_value_t 	*pv_name;
	char		*name_prop; /* set name property	*/

	if (strcmp(rtype, PSET_TYPE_NAME) == 0) {
		if ((pv_sys_id = create_pool_value(PSET_SYSID)) == NULL)
			goto on_error;
		name_prop = PSET_NAME;
	} else {
		die(gettext(ERR_UNSUPP_RTYPE), rtype);
	}

	if ((pvals[0] = create_pool_value("type")) == NULL)
		goto on_error;
	if ((pool_value_set_string(pvals[0], rtype)) == -1)
		goto on_error;

	if ((pv_name = create_pool_value(name_prop)) == NULL)
		goto on_error;

	if (pool_name != NULL) {
		/* collect resources associated to 'pool_name'	*/
		pool_t 	*pool;
		if ((pool = pool_get_pool(conf, pool_name)) == NULL)
			die(gettext(ERR_STATS_POOL_N), pool_name);
		if ((resources = pool_query_pool_resources(
		    conf, pool, nelem, pvals)) == NULL)
			goto on_error;
	} else {
		/* collect all resources  */
		if ((resources =
		    pool_query_resources(conf, nelem, pvals)) == NULL)
			goto on_error;
	}

	if (pv_name != NULL)
		pool_value_free(pv_name);
	if (pv_sys_id != NULL)
		pool_value_free(pv_sys_id);
	if (pvals[0] != NULL)
		pool_value_free(pvals[0]);

	return (resources);
on_error:
	die(gettext(ERR_STATS_RES), get_errstr());
	/*NOTREACHED*/
}

/*
 * Print statistics for all resources of type 'rtype' passed in 'resources'.
 */
static void
prt_resource_stats_by_type(pool_resource_t **resources, const char *rtype)
{
	int		i;
	pool_elem_t	*elem;
	pool_value_t 	*pv_name;
	char		*name_prop;

	poolstat_line_format_t	*lf;
	statistic_bag_t		*sbag;

	if (strcmp(rtype, PSET_TYPE_NAME) == 0) {
		name_prop = PSET_NAME;
		lf = &pset_lf;
		sbag = pset_sbag;
	} else {
		die(gettext(ERR_UNSUPP_RTYPE), rtype);
	}

	if ((pv_name = create_pool_value(name_prop)) == NULL)
		goto on_error;

	/* collect and print statistics for the given resources	*/
	for (i = 0; resources[i] != NULL; i++) {
		if ((elem = pool_resource_to_elem(conf, resources[i])) == NULL)
			goto on_error;
		if (pool_get_property(conf, elem, name_prop, pv_name) == -1)
			goto on_error;
		if (pool_value_get_string(pv_name, &sbag->sb_name) == -1)
			goto on_error;
		sa_update(sbag, 0);

		prt_stat_line(lf);
	}

	if (pv_name != NULL)
		pool_value_free(pv_name);
	return;
on_error:
	die(gettext(ERR_STATS_RES), get_errstr());
}

/*
 * Update statistics for all resources of type 'rtype' pased in 'resources'.
 */
static void
update_resource_stats(pool_resource_t *resource, const char *rtype)
{
	pool_elem_t	*elem;
	pool_value_t 	*pv_name;
	char		*name_prop; 		/* set name property	*/

	statistic_bag_t	*sbag;

	if (strcmp(rtype, PSET_TYPE_NAME) == 0) {
		name_prop = PSET_NAME;
		sbag 	= pset_sbag;
	} else {
		die(gettext(ERR_UNSUPP_RTYPE), rtype);
	}

	if ((pv_name = create_pool_value(name_prop)) == NULL)
		goto on_error;

	if ((elem = pool_resource_to_elem(conf, resource)) == NULL)
		goto on_error;
	if (pool_get_property(conf, elem, name_prop, pv_name) == -1)
		goto on_error;
	if (pool_value_get_string(pv_name, &sbag->sb_name) == -1)
		goto on_error;
	sa_update(sbag, 0);

	if (pv_name != NULL)
		pool_value_free(pv_name);
	return;

on_error:
	die(gettext(ERR_STATS_RES), get_errstr());
}

/*
 * For each pool in the configuration print statistics of associated resources.
 * If the pool name list 'pn' is defined, only print resources of pools
 * specified in the list. The list can specify the pool name or its system id.
 */
static void
prt_pool_stats(poolstat_list_element_t *pn)
{
	uint_t 		nelem;
	pool_elem_t	*elem;
	int		i;
	int 		error;
	pool_t 		**pools = NULL;
	pool_value_t 	*pvals[] = { NULL, NULL };
	pool_value_t 	*pv_name = NULL;
	pool_value_t 	*pv_sys_id = NULL;
	statistic_bag_t	*sbag = pool_sbag;
	poolstat_list_element_t 	*rtype;
	pool_resource_t **resources;

	if ((pv_sys_id = create_pool_value(POOL_SYSID)) == NULL)
		goto on_error;
	if ((pv_name = create_pool_value(POOL_NAME)) == NULL)
		goto on_error;

	if (pn == NULL) {
		/* collect all pools	*/
		if ((pools = pool_query_pools(conf, &nelem, NULL)) == NULL)
			goto on_error;
	} else {
		/*
		 * collect pools specified in the 'pn' list.
		 * 'poolid' the pool identifier can be a pool name or sys_id.
		 */
		poolstat_list_element_t	*poolid;
		for (poolid = pn, i = 1; poolid; poolid = poolid->ple_next)
			i++;
		pools = ZALLOC(sizeof (pool_t *) * (i + 1));
		for (poolid = pn, i = 0; poolid;
		    poolid = poolid->ple_next, i++) {
			pool_t **pool;
			int64_t sysid = Atoi(poolid->ple_obj, &error);
			if (error == 0) {
				/* the pool is identified by sys_id	*/
				pool_value_set_int64(pv_sys_id, sysid);
				pvals[0] = pv_sys_id;
				pool = pool_query_pools(conf, &nelem, pvals);
			} else {
				if (pool_value_set_string(pv_name,
				    poolid->ple_obj) == -1)
					die(gettext(ERR_NOMEM));
				pvals[0] = pv_name;
				pool = pool_query_pools(conf, &nelem, pvals);
			}
			if (pool == NULL)
				die(gettext(ERR_STATS_POOL_N), poolid->ple_obj);
			pools[i] = pool[0];
			FREE(pool);
		}
	}

	/* print statistic for all pools found		*/
	if (!rflag) {
		/* print the common resource header 	*/
		prt_stat_hd(POOL_TYPE_NAME);

		/* print statistics for the resources bound to the pools */
		for (i = 0; pools[i] != NULL; i++) {
			elem = pool_to_elem(conf, pools[i]);
			if (pool_get_property(conf, elem, POOL_NAME, pv_name)
			    == -1)
				goto on_error;
			if (pool_value_get_string(pv_name, &sbag->sb_name) != 0)
				goto on_error;
			if (pool_get_property(
			    conf, elem, "pool.sys_id", pv_sys_id) == -1)
				goto on_error;
			if (pool_value_get_int64(
			    pv_sys_id, &sbag->sb_sysid) != 0)
				goto on_error;

			for (rtype = rtypes; rtype; rtype = rtype->ple_next) {
				resources = get_resources(
				    sbag->sb_name, rtype->ple_obj, &nelem);
				update_resource_stats(*resources,
				    rtype->ple_obj);
				FREE(resources);
			}
			prt_stat_line(&pool_lf);
		}
	} else {
		/* print statistic for all resource types defined in rtypes */
		for (rtype = rtypes; rtype; rtype = rtype->ple_next) {
			prt_stat_hd(rtype->ple_obj);
			for (i = 0; pools[i] != NULL; i++) {
				elem = pool_to_elem(conf, pools[i]);
				if (pool_get_property(
				    conf, elem, POOL_NAME, pv_name) == -1)
					goto on_error;
				if (pool_value_get_string(
				    pv_name, &sbag->sb_name) != 0)
					goto on_error;
				if (pool_get_property(
				    conf, elem, POOL_SYSID, pv_sys_id) == -1)
					goto on_error;
				if (pool_value_get_int64(
				    pv_sys_id, &sbag->sb_sysid) != 0)
					goto on_error;
				resources = get_resources(
				    sbag->sb_name, rtype->ple_obj, &nelem);
				if (resources == NULL)
					continue;
				update_resource_stats(
				    *resources, rtype->ple_obj);
				prt_resource_stats_by_type(resources,
				    rtype->ple_obj);
				FREE(resources);
			}
		}
	}

	FREE(pools);
	if (pv_name != NULL)
		pool_value_free(pv_name);
	if (pv_sys_id != NULL)
		pool_value_free(pv_sys_id);

	return;
on_error:
	die(gettext(ERR_STATS_POOL), get_errstr());
}