xref: /illumos-gate/usr/src/cmd/zonestat/zonestat/zonestat.c (revision bbf21555)

/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <alloca.h>
#include <assert.h>
#include <errno.h>
#include <langinfo.h>
#include <libintl.h>
#include <libscf.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/fxpriocntl.h>
#include <sys/priocntl.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <zonestat.h>

extern char *optarg;
extern int optind, opterr, optopt;

#define	ZSTAT_OK		0
#define	ZSTAT_ERROR		1
#define	ZSTAT_USAGE		2

#define	ZSTAT_UNIX_TIMESTAMP	1
#define	ZSTAT_ISO_TIMESTAMP	2
#define	ZSTAT_DATE_TIMESTAMP	3

#define	ZSTAT_RES_PHYSICAL_MEMORY	0x1
#define	ZSTAT_RES_VIRTUAL_MEMORY	0x2
#define	ZSTAT_RES_LOCKED_MEMORY		0x4
#define	ZSTAT_RES_MEMORY		0x7

#define	ZSTAT_RES_DEFAULT_PSET		0x10
#define	ZSTAT_RES_PSETS			0x20
#define	ZSTAT_RES_SUMMARY		0x40

#define	ZSTAT_RES_PROCESSES		0x100
#define	ZSTAT_RES_LWPS			0x200
#define	ZSTAT_RES_LOFI			0x400
#define	ZSTAT_RES_LIMITS		0x700

#define	ZSTAT_RES_SHM_MEMORY		0x1000
#define	ZSTAT_RES_SHM_IDS		0x2000
#define	ZSTAT_RES_SEM_IDS		0x4000
#define	ZSTAT_RES_MSG_IDS		0x8000
#define	ZSTAT_RES_SYSV			0xF000

#define	ZSTAT_RES_ALL			0xF777

#define	ZONESTAT_PHYSICAL_MEMORY	"physical-memory"
#define	ZONESTAT_VIRTUAL_MEMORY		"virtual-memory"
#define	ZONESTAT_LOCKED_MEMORY		"locked-memory"
#define	ZONESTAT_MEMORY			"memory"

#define	ZONESTAT_DEFAULT_PSET		"default-pset"
#define	ZONESTAT_POOL_PSET		"pool-pset"
#define	ZONESTAT_PSRSET_PSET		"psrset-pset"
#define	ZONESTAT_DEDICATED_CPU		"dedicated-cpu"
#define	ZONESTAT_PROCESSOR_SET		"processor-set"
#define	ZONESTAT_PSETS			"psets"
#define	ZONESTAT_SUMMARY		"summary"

#define	ZONESTAT_PROCESSES		"processes"
#define	ZONESTAT_LWPS			"lwps"
#define	ZONESTAT_LOFI			"lofi"
#define	ZONESTAT_LIMITS			"limits"

#define	ZONESTAT_SHM_MEMORY		"shm-memory"
#define	ZONESTAT_SHM_IDS		"shm-ids"
#define	ZONESTAT_SEM_IDS		"sem-ids"
#define	ZONESTAT_MSG_IDS		"msg-ids"
#define	ZONESTAT_SYSV			"sysv"

#define	ZONESTAT_ALL			"all"

#define	ZONESTAT_NAME_MEM_DEFAULT	"mem_default"
#define	ZONESTAT_NAME_VM_DEFAULT	"vm_default"

#define	ZONESTAT_NAME_AVERAGE		"average"
#define	ZONESTAT_NAME_HIGH		"high"

#define	ZONESTAT_NAME_RESOURCE		"resource"
#define	ZONESTAT_NAME_TOTAL		"total"
#define	ZONESTAT_NAME_SYSTEM		"system"
#define	ZONESTAT_NAME_ZONES		"zones"
#define	ZONESTAT_NAME_HEADER		"header"
#define	ZONESTAT_NAME_FOOTER		"footer"

#define	ZONESTAT_NAME_NAME		"name"
#define	ZONESTAT_NAME_USED		"used"
#define	ZONESTAT_NAME_CAP		"cap"
#define	ZONESTAT_NAME_PCAP		"pcap"
#define	ZONESTAT_NAME_SHR		"shr"
#define	ZONESTAT_NAME_PSHRU		"pshru"
#define	ZONESTAT_NAME_CPU		"cpu"
#define	ZONESTAT_NAME_PHYSICAL_MEMORY	ZONESTAT_PHYSICAL_MEMORY
#define	ZONESTAT_NAME_VIRTUAL_MEMORY	ZONESTAT_VIRTUAL_MEMORY

#define	ZONESTAT_NAME_SYSTEM_LIMIT	"system-limit"

#define	ZSTAT_REPORT_FMT_INTERVAL	0
#define	ZSTAT_REPORT_FMT_TOTAL		1
#define	ZSTAT_REPORT_FMT_AVERAGE	2
#define	ZSTAT_REPORT_FMT_HIGH		3
#define	ZSTAT_REPORT_FMT_END		4

#define	ZSTAT_REPORT_TEXT_INTERVAL	"interval"
#define	ZSTAT_REPORT_TEXT_TOTAL		"report-total"
#define	ZSTAT_REPORT_TEXT_AVERAGE	"report-average"
#define	ZSTAT_REPORT_TEXT_HIGH		"report-high"
#define	ZSTAT_REPORT_TEXT_END		"footer"

#define	ZSTAT_DURATION_INF	((int)INT_MAX)
#define	ZSTAT_INTERVAL_DEFAULT	((int)INT_MAX)
#define	ZSTAT_REPORT_END	((int)INT_MAX)

#define	ZSTAT_SORT_CPU		1
#define	ZSTAT_SORT_PHYSICAL	2
#define	ZSTAT_SORT_VIRTUAL	3
#define	ZSTAT_SORT_USED		4
#define	ZSTAT_SORT_CAP		5
#define	ZSTAT_SORT_PCAP		6
#define	ZSTAT_SORT_SHR		7
#define	ZSTAT_SORT_PSHRU	8
#define	ZSTAT_SORT_NAME		9
#define	ZSTAT_SORT_MAX		10

#define	ZSTAT_SUM_MIN_ZONENAME 19
#define	ZSTAT_SUM_HDR_FORMAT "%23s %17s %17s\n"
#define	ZSTAT_SUM_ZONE_FORMAT "%5s %5s %5s %5s %5s %5s %5s %5s %5s %5s\n"

#define	ZSTAT_CPU_MIN_PSETNAME 22
#define	ZSTAT_CPU_MIN_ZONENAME 36
#define	ZSTAT_CPU_RES_FORMAT "%13s  %11s %11s\n"
#define	ZSTAT_CPU_ZONE_FORMAT "%5s %5s %5s %5s %6s %5s %5s\n"

#define	ZSTAT_RESOURCE_MIN_RESNAME 28
#define	ZSTAT_RESOURCE_MIN_ZONENAME 36
#define	ZSTAT_RESOURCE_FORMAT "%13s\n"
#define	ZSTAT_RESOURCE_ZONE_FORMAT "%5s %5s %5s %5s\n"

#define	ZS_UINT64_STRLEN 20
#define	ZS_PCT_STRLEN	10
#define	ZS_TIME_STRLEN	20
#define	ZS_NAME_STRLEN	10

time_t g_now_time;
time_t g_boot_time;
time_t g_start_time;
time_t g_end_time;
int g_interval;
int g_count;
int g_report_count;
time_t g_seconds;

int g_resources;
zs_ctl_t *g_zsctl;
boolean_t g_quit = B_FALSE;
zs_zone_t **g_zone_list;
int g_zone_num;
zs_pset_zone_t **g_pz_list;
int g_pz_num;
zs_pset_t **g_pset_list;
int g_pset_num;
int g_sort_by;
int g_sorts[ZSTAT_SORT_MAX];
int g_sort_summary;
size_t g_max_zonename;

/* Storage for command line arguments. */
char **arg_zonenames;
int arg_zonename_count;
char **arg_resnames;
int arg_resname_count;
char **arg_restypes;
int arg_restype_count;
char ** arg_reports;
int arg_report_count;
char ** arg_sort_list;
int arg_sort_count;
char ** arg_line_list;
int arg_line_count;

time_t arg_starttime;
time_t arg_endtime;
uint_t arg_timestamp = ZSTAT_DATE_TIMESTAMP;
int arg_interval = 5;
int arg_duration = -1;
int arg_report = -1;

/* Options with or as arguments */
boolean_t opt_zonenames = B_FALSE;
boolean_t opt_resnames = B_FALSE;
boolean_t opt_restypes = B_FALSE;
boolean_t opt_start = B_FALSE;
boolean_t opt_end = B_FALSE;
boolean_t opt_in = B_FALSE;
boolean_t opt_out = B_FALSE;
boolean_t opt_timestamp = B_FALSE;
boolean_t opt_report = B_FALSE;
boolean_t opt_sort = B_FALSE;

boolean_t opt_report_high = B_FALSE;
boolean_t opt_report_total = B_FALSE;
boolean_t opt_report_average = B_FALSE;

boolean_t opt_line_resource = B_FALSE;
boolean_t opt_line_total = B_FALSE;
boolean_t opt_line_system = B_FALSE;
boolean_t opt_line_zones = B_FALSE;
boolean_t opt_line_header = B_FALSE;
boolean_t opt_line_any = B_FALSE;

/* Options without arguments */
boolean_t opt_quiet_intervals = B_FALSE;
boolean_t opt_parseable = B_FALSE;
boolean_t opt_debug = B_FALSE;

static int
zonestat_usage(boolean_t explicit)
{
	FILE *fd = explicit ? stdout : stderr;

	(void) fprintf(fd, gettext("Usage:\n"));
	(void) fprintf(fd,
"    zonestat [-z zonelist] [-r reslist] [-n namelist]\n"
"             [-T u | d | i] [-R reports] [-q] [-p [-P lines]] [-S cols]\n"
"             interval [duration [report]]\n"
"\n");
	(void) fprintf(fd, gettext(
"    Options:\n"
"    %s    Report resources of specified types.\n"
"	    Valid resource types are:\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      \"%s\", \"%s\", \"%s\"\n"
"	      \"%s\", \"%s\", \"%s\", \"%s\"\n"),
	    "-r",
	    ZONESTAT_VIRTUAL_MEMORY, ZONESTAT_PHYSICAL_MEMORY,
	    ZONESTAT_LOCKED_MEMORY, ZONESTAT_PROCESSOR_SET,
	    ZONESTAT_PROCESSES, ZONESTAT_LWPS, ZONESTAT_LOFI,
	    ZONESTAT_SHM_MEMORY, ZONESTAT_SHM_IDS, ZONESTAT_SEM_IDS,
	    ZONESTAT_MSG_IDS);

	(void) fprintf(fd, gettext(
"	    The following resource nicknames can also be specified:\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      \"%s\"\n"),
	    ZONESTAT_SUMMARY, ZONESTAT_MEMORY, ZONESTAT_PSETS,
	    ZONESTAT_DEFAULT_PSET, ZONESTAT_LIMITS, ZONESTAT_SYSV);
	(void) fprintf(fd, gettext(
"    %s    Report resources used by zones\n"
"    %s    Report resources with specific names.\n"
"	    Valid resource names are:\n"
"	      \"%s\"\n"
"	      \"%s\"\n"
"	      Name of a pool processor set\n"
"	      Id of a processor set created with psrset(8)\n"
"	      Name of a zone using dedicated-cpu\n"),
	    "-z", "-n",
	    ZONESTAT_NAME_MEM_DEFAULT, ZONESTAT_NAME_VM_DEFAULT);
	(void) fprintf(fd, gettext(
"    %s    Print timestamp. Valid timestamps are:\n"
"	      \"%s\"\tDate as specifed by date(1) command\n"
"	      \"%s\"\tUnix time as returned by time(2)\n"
"	      \"%s\"\tISO 8601 timestamp \"%s\"\n"
"    %s    Print reports at end or after each report interval.\n"
"	    Valid reports are:\n"
"	      \"%s\"\tUsage of each zone\n"
"	      \"%s\"\tUsage of each zone while running\n"
"	      \"%s\"\tMaximum usage of each zone\n"
"    %s    Quiet.  Do not print intervals.  Only print reports.\n"
"    %s    Machine parseable output.\n"),
	    "-T", "d", "u", "i", "YYYYMMDDThhmmssZ",
	    "-R", ZONESTAT_NAME_TOTAL, ZONESTAT_NAME_AVERAGE,
	    ZONESTAT_NAME_HIGH,
	    "-q", "-p");

	(void) fprintf(fd, gettext(
"    %s    Select desired lines in parseable output.\n"
"	      \"%s\"\tLines describing each resource\n"
"	      \"%s\"\tTotal usage of each resource\n"
"	      \"%s\"\tSystem usage of each resource\n"
"	      \"%s\"\tPer-zone usage of each resource\n"
"	      \"%s\"\tHeader lines between intervals and reports\n"),
	    "-P", ZONESTAT_NAME_RESOURCE, ZONESTAT_NAME_TOTAL,
	    ZONESTAT_NAME_SYSTEM, ZONESTAT_NAME_ZONES, ZONESTAT_NAME_HEADER);

	(void) fprintf(fd, gettext(
"    %s    Sort output by the specified columns:\n"
"	      \"%s\"\tby name alphanumerically\n"
"	      \"%s\"\tby percent of resource used\n"
"	      \"%s\"\tby configured cap\n"
"	      \"%s\"\tby percent of cap used\n"
"	      \"%s\"\tby shares configured\n"
"	      \"%s\"\tby percent of share used\n"
"	      \"%s\"\tSort summary by cpu\n"
"	      \"%s\"\tSort summary by physical memory\n"
"	      \"%s\"\tSort summary by virtual memory\n"),
	    "-S", ZONESTAT_NAME_NAME, ZONESTAT_NAME_USED, ZONESTAT_NAME_CAP,
	    ZONESTAT_NAME_PCAP, ZONESTAT_NAME_SHR, ZONESTAT_NAME_PSHRU,
	    ZONESTAT_NAME_CPU, ZONESTAT_NAME_PHYSICAL_MEMORY,
	    ZONESTAT_NAME_VIRTUAL_MEMORY);

	if (!explicit)
		(void) fputs("\n", fd);
	return (ZSTAT_USAGE);
}

/* PRINTFLIKE1 */
static int
zonestat_error(const char *fmt, ...)
{
	va_list alist;

	va_start(alist, fmt);

	(void) fprintf(stderr, "zonestat: Error: ");
	(void) vfprintf(stderr, fmt, alist);
	(void) fprintf(stderr, "\n");
	va_end(alist);
	return (ZSTAT_ERROR);
}

static void
zonestat_determine_lines()
{
	int i;
	boolean_t fail = B_FALSE;

	if (arg_line_count == 0) {
		opt_line_resource = B_TRUE;
		opt_line_total = B_TRUE;
		opt_line_system = B_TRUE;
		opt_line_zones = B_TRUE;
		opt_line_header = B_TRUE;
	}
	for (i = 0; i < arg_line_count; i++) {
		if (strcmp(arg_line_list[i], ZONESTAT_NAME_RESOURCE) == 0)
			opt_line_resource = B_TRUE;
		else if (strcmp(arg_line_list[i], ZONESTAT_NAME_TOTAL) == 0)
			opt_line_total = B_TRUE;
		else if (strcmp(arg_line_list[i], ZONESTAT_NAME_SYSTEM) == 0)
			opt_line_system = B_TRUE;
		else if (strcmp(arg_line_list[i], ZONESTAT_NAME_ZONES) == 0)
			opt_line_zones = B_TRUE;
		else if (strcmp(arg_line_list[i], ZONESTAT_NAME_HEADER) == 0)
			opt_line_header = B_TRUE;
		else {
			(void) zonestat_error(gettext("Unknown -O arg: %s"),
			    arg_line_list[i]);
			fail = B_TRUE;
		}
	}
	if (fail == B_TRUE)
		exit(zonestat_usage(B_FALSE));
}

static void
zonestat_determine_reports()
{
	int i;
	boolean_t fail = B_FALSE;

	for (i = 0; i < arg_report_count; i++) {
		if (strcmp(arg_reports[i], ZONESTAT_NAME_TOTAL) == 0)
			opt_report_total = B_TRUE;
		else if (strcmp(arg_reports[i], ZONESTAT_NAME_AVERAGE) == 0)
			opt_report_average = B_TRUE;
		else if (strcmp(arg_reports[i], ZONESTAT_NAME_HIGH) == 0)
			opt_report_high = B_TRUE;
		else {
			(void) zonestat_error(gettext("Unknown -R arg: %s"),
			    arg_reports[i]);
			fail = B_TRUE;
		}
	}
	if (fail == B_TRUE)
		exit(zonestat_usage(B_FALSE));
}

/*
 * Compares list of -S sort arguments to the list of known sorts.  Only
 * one of cpu, physical memory, and virtual memory can be specified.
 */
static void
zonestat_determine_sort()
{
	int i, count = 0;
	boolean_t fail = B_FALSE;

	if (arg_sort_count == 0) {
		g_sort_summary = ZS_RESOURCE_CPU;
		g_sorts[0] = ZSTAT_SORT_USED;
		g_sorts[1] = ZSTAT_SORT_NAME;
		arg_sort_count = 2;
		return;
	}

	if (arg_sort_count > ZSTAT_SORT_MAX)
		exit(zonestat_error(gettext(
		    "Too many -S sort columns specified")));

	for (i = 0; i < arg_sort_count; i++) {
		if (strcmp(arg_sort_list[i], ZONESTAT_NAME_NAME) == 0)
			g_sorts[count++] = ZSTAT_SORT_NAME;
		else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_USED) == 0)
			g_sorts[count++] = ZSTAT_SORT_USED;
		else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_CAP) == 0)
			g_sorts[count++] = ZSTAT_SORT_CAP;
		else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_PCAP) == 0)
			g_sorts[count++] = ZSTAT_SORT_PCAP;
		else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_SHR) == 0)
			g_sorts[count++] = ZSTAT_SORT_SHR;
		else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_PSHRU) == 0)
			g_sorts[count++] = ZSTAT_SORT_PSHRU;
		else if (strcmp(arg_sort_list[i], ZONESTAT_NAME_CPU) == 0) {
			if (g_sort_summary != 0)
				fail = B_TRUE;
			g_sort_summary = ZS_RESOURCE_CPU;
		} else if (strcmp(arg_sort_list[i],
		    ZONESTAT_NAME_PHYSICAL_MEMORY) == 0) {
			if (g_sort_summary != 0)
				fail = B_TRUE;
			g_sort_summary = ZS_RESOURCE_RAM_RSS;
		} else if (strcmp(arg_sort_list[i],
		    ZONESTAT_NAME_VIRTUAL_MEMORY) == 0) {
			if (g_sort_summary != 0)
				fail = B_TRUE;
			g_sort_summary = ZS_RESOURCE_VM;
		} else {
			(void) zonestat_error(gettext("Unknown -S arg: %s"),
			    arg_sort_list[i]);
			fail = B_TRUE;
		}
	}
	if (g_sort_summary == 0)
		g_sort_summary = ZS_RESOURCE_CPU;

	if (fail == B_TRUE) {
		(void) zonestat_error(gettext(
		    "-S: only one of \"%s\", \"%s\", or "
		    "\"%s\" permitted"), "-S", ZONESTAT_NAME_CPU,
		    ZONESTAT_NAME_PHYSICAL_MEMORY,
		    ZONESTAT_NAME_VIRTUAL_MEMORY);
		exit(zonestat_usage(B_FALSE));
	}
}

typedef struct zonestat_resource_struct {
	char *zr_name;
	uint_t zr_flag;
} zonestat_resource_t;


/* Used to map resource name strings to resource flags */
zonestat_resource_t g_resource_list[] = {
	ZONESTAT_PHYSICAL_MEMORY, ZSTAT_RES_PHYSICAL_MEMORY,
	ZONESTAT_VIRTUAL_MEMORY, ZSTAT_RES_VIRTUAL_MEMORY,
	ZONESTAT_LOCKED_MEMORY, ZSTAT_RES_LOCKED_MEMORY,
	ZONESTAT_MEMORY, ZSTAT_RES_MEMORY,
	ZONESTAT_PROCESSOR_SET, ZSTAT_RES_PSETS,
	ZONESTAT_PSETS, ZSTAT_RES_PSETS,
	ZONESTAT_DEFAULT_PSET, ZSTAT_RES_DEFAULT_PSET,
	ZONESTAT_PROCESSES, ZSTAT_RES_PROCESSES,
	ZONESTAT_LWPS, ZSTAT_RES_LWPS,
	ZONESTAT_LOFI, ZSTAT_RES_LOFI,
	ZONESTAT_LIMITS, ZSTAT_RES_LIMITS,
	ZONESTAT_SHM_MEMORY, ZSTAT_RES_SHM_MEMORY,
	ZONESTAT_SHM_IDS, ZSTAT_RES_SHM_IDS,
	ZONESTAT_SEM_IDS, ZSTAT_RES_SEM_IDS,
	ZONESTAT_MSG_IDS, ZSTAT_RES_MSG_IDS,
	ZONESTAT_SYSV, ZSTAT_RES_SYSV,
	ZONESTAT_SUMMARY, ZSTAT_RES_SUMMARY,
	ZONESTAT_ALL, ZSTAT_RES_ALL
};

/*
 * Compares list of resources passed to -r to the known list of
 * resources.
 */
static void
zonestat_determine_resources()
{
	int i, j, count;
	boolean_t found, fail = B_FALSE;

	if (arg_restype_count == 0) {
		g_resources = ZSTAT_RES_SUMMARY;
		return;
	}

	count = sizeof (g_resource_list) / sizeof (zonestat_resource_t);

	for (i = 0; i < arg_restype_count; i++) {
		found = B_FALSE;
		for (j = 0; j < count; j++) {
			if (strcmp(arg_restypes[i], g_resource_list[j].zr_name)
			    == 0) {
				g_resources |= g_resource_list[j].zr_flag;
				found = B_TRUE;
				break;
			}
		}
		if (found == B_FALSE) {
			(void) zonestat_error(gettext("Unknown resource: %s"),
			    arg_restypes[i]);
			fail = B_TRUE;
		}
	}
	if (fail == B_TRUE)
		exit(zonestat_usage(B_FALSE));
}

/*
 * Returns 1 if the name matches one of the specified zone names.  0
 * otherwise.  Always matches if no zone names were specified.
 */
static int
zonestat_match_zonename(char *name)
{
	int i;

	if (arg_zonename_count == 0)
		return (1);
	for (i = 0; i < arg_zonename_count; i++) {
		if (strcmp(name, arg_zonenames[i]) == 0)
			return (1);
	}
	return (0);
}

/*
 * compare name to base, ignoring prefix on name.
 */
static int
zonestat_match_with_prefix(char *prefix, char *name, char *base)
{
	size_t prefix_len;

	prefix_len = strlen(prefix);
	if (strncmp(name, prefix, prefix_len) == 0) {
		name += prefix_len;
		if (strcmp(name, base) == 0)
			return (1);
	}
	return (0);
}
/*
 * Returns 1 if the resource matches one of the specified resource names.  0
 * otherwise.  Always matches if no resource names were specified.
 */
static int
zonestat_match_resname(char *name)
{
	int i;

	if (arg_resname_count == 0)
		return (1);
	for (i = 0; i < arg_resname_count; i++) {

		if (strcmp(name, arg_resnames[i]) == 0)
			return (1);

		if (zonestat_match_with_prefix("SUNWtmp_", name,
		    arg_resnames[i]))
			return (1);

		if (zonestat_match_with_prefix("SUNWlegacy_pset_", name,
		    arg_resnames[i]))
			return (1);
	}
	return (0);
}

/*
 * Format unsigned uint64_t
 *
 * 9999  9999
 * 99.9K 99999
 * 9999K 9999999
 * 99.9M 99999999
 * 9999M 9999999999
 * 99.9G 99999999999
 * 9999G 9999999999999
 * 99.9T 99999999999999
 * 9999T 9999999999999999
 * 99.9P 99999999999999999
 * 9999P 9999999999999999999
 * 99.9E UINT64_MAX
 */
static void
format_uint64(uint64_t val, char *str, size_t len)
{
	uint64_t high;
	uint64_t low;

	if (val == UINT64_MAX) {
		(void) snprintf(str, len, "-");
		return;
	}
	if (val <= 9999) {
		(void) snprintf(str, len, "%llu", val);
		return;
	}
	if (val <= 99999) {
		high = val / 1024;
		low = val * 10 / 1024 - (high * 10);
		(void) snprintf(str, len, "%llu%1.1lluK", high, low);
		return;
	}
	val = val / 1024;
	if (val <= 9999 || opt_parseable) {
		high = val;
		(void) snprintf(str, len, "%lluK", high);
		return;
	}
	if (val <= 99999) {
		high = val / 1024;
		low = val * 10 / 1024 - (high * 10);
		(void) snprintf(str, len, "%llu.%1.1lluM", high, low);
		return;
	}
	val = val / 1024;
	if (val <= 9999) {
		high = val;
		(void) snprintf(str, len, "%lluM", high);
		return;
	}
	if (val <= 99999) {
		high = val / 1024;
		low = val * 10 / 1024 - (high * 10);
		(void) snprintf(str, len, "%llu.%1.1lluG", high, low);
		return;
	}
	val = val / 1024;
	if (val <= 9999) {
		high = val;
		(void) snprintf(str, len, "%lluG", high);
		return;
	}
	if (val <= 99999) {
		high = val / 1024;
		low = val * 10 / 1024 - (high * 10);
		(void) snprintf(str, len, "%llu.%1.1lluT", high, low);
		return;
	}
	val = val / 1024;
	if (val <= 9999) {
		high = val;
		(void) snprintf(str, len, "%lluT", high);
		return;
	}
	if (val <= 99999) {
		high = val / 1024;
		low = val * 10 / 1024 - (high * 10);
		(void) snprintf(str, len, "%llu.%1.1lluP", high, low);
		return;
	}
	val = val / 1024;
	if (val <= 9999) {
		high = val;
		(void) snprintf(str, len, "%lluP", high);
		return;
	}
	high = val / 1024;
	low = val * 10 / 1024 - (high * 10);
	(void) snprintf(str, len, "%llu.%1.1lluE", high, low);
}


static void
format_pct(uint_t pct, char *str, size_t len)
{
	uint_t high;
	uint_t low;

	if (pct == ZS_PCT_NONE) {
		(void) snprintf(str, len, "-");
		return;
	}
	/*
	 * pct's are printed as one of:
	 *	#.##%
	 *	##.#%
	 *	 ###%
	 *	####%
	 *
	 * The value is fixed decimal.  10000 equals 100.00 percent.
	 * Percents can exceed 100.00 percent.  Percents greater than
	 * 9999% will exceed the 5 column width.
	 */
	if (pct <= 999 || opt_parseable) {
		high = pct / 100;
		low = pct - (high * 100);
		(void) snprintf(str, len, "%u.%2.2u%%", high, low);
	} else if (pct <= 9999) {
		pct = pct / 10;
		high = pct / 10;
		low = pct - (high * 10);
		(void) snprintf(str, len, "%u.%1.1u%%", high, low);
	} else {
		pct = pct / 100;
		(void) snprintf(str, len, "%u%%", pct);
	}
}
/*
 * Cpu cap is 100 times the number of cpus allocated.  It is formatted as a
 * decimal.  Example, a cpu-cap of 50 is 0.50 cpus.
 *
 * The cpu cap value can go up to UINT_MAX, so handle all cases even though
 * the higher ones are nonsense.
 *
 * Format  Max cpu-cap value for format.
 * 42.9M   4294967296
 * 9999K   999999999
 * 99.9K   9999999
 *  9999   999999
 * 999.9   99999
 *  9.99   999
 */
void
format_cpu(uint64_t cpu, char *str, size_t len)
{

	uint64_t high;
	uint64_t low;

	/* #.## cpus */
	if (cpu <= 999 || opt_parseable) {
		high = cpu / 100;
		low = cpu - (high * 100);
		(void) snprintf(str, len, "%llu.%2.2llu", high, low);
		return;
	}
	/* ##.# cpus */
	if (cpu <= 99999) {
		high = cpu / 100;
		low = cpu - (high * 100);
		(void) snprintf(str, len, "%llu.%1.1llu", high, low);
		return;
	}
	/* #### cpus */
	if (cpu <= 999999) {
		cpu = cpu / 100;
		(void) snprintf(str, len, "%llu", cpu);
		return;
	}
	/* ##.#K cpus */
	cpu = cpu / 1000;
	if (cpu <= 99999) {
		high = cpu / 100;
		low = cpu - (high * 100);
		(void) snprintf(str, len, "%llu.%1.1lluK", high, low);
		return;
	}
	/* ####K cpus */
	if (cpu <= 999999) {
		cpu = cpu / 100;
		(void) snprintf(str, len, "%lluK", cpu);
		return;
	}
	/* ##.#M cpus */
	cpu = cpu / 1000;
	if (cpu <= UINT_MAX) {
		high = cpu / 100;
		low = cpu - (high * 100);
		(void) snprintf(str, len, "%llu.%1.1lluM", high, low);
		return;
	}
	(void) snprintf(str, len, "error", high, low);
}

/*
 * Format a timetruct as:
 * HH:MM:SS.SS
 *
 * Human readable format omits the fractional seconds.
 */
static void
format_ts(timestruc_t *ts, char *str, size_t len, boolean_t human_readable)
{
	uint64_t secs, mins, hours, pct;

	hours = 0;
	mins = 0;

	secs = ts->tv_sec;
	pct = ts->tv_nsec / 1000 / 1000 / 10;
	while (pct >= 100) {
		pct -= 100;
		secs++;
	}
	if (secs >= 60) {
		mins = secs / 60;
		secs = secs % 60;
	}
	if (mins >= 60) {
		hours = mins / 60;
		mins = mins % 60;
	}
	if (human_readable)
		(void) snprintf(str, len, "%llu:%2.2llu:%2.2llu", hours,
		    mins, secs);
	else
		(void) snprintf(str, len, "%llu-%2.2llu-%2.2llu.%2.2llu", hours,
		    mins, secs, pct);
}

char *g_report_formats[] = {
	ZSTAT_REPORT_TEXT_INTERVAL,
	ZSTAT_REPORT_TEXT_TOTAL,
	ZSTAT_REPORT_TEXT_AVERAGE,
	ZSTAT_REPORT_TEXT_HIGH,
	ZSTAT_REPORT_TEXT_END
};

/* Get the label for the current report type */
static char *
zonestat_get_plabel(int format)
{
	if (format >= sizeof (g_report_formats) / sizeof (char *))
		exit(zonestat_error(gettext(
		    "Internal error, invalid report format")));

	return (g_report_formats[format]);
}

#define	ZSTAT_CPULINE "----------CPU----------"
#define	ZSTAT_MEMLINE "----PHYSICAL-----"
#define	ZSTAT_VMLINE  "-----VIRTUAL-----"

static void
zonestat_print_summary_header(size_t namewidth, int report_fmt, uint64_t cpu,
    uint64_t online, uint64_t mem, uint64_t vm)
{
	char str_cpu[ZS_UINT64_STRLEN];
	char str_online[ZS_UINT64_STRLEN];
	char str_mem[ZS_UINT64_STRLEN];
	char str_vm[ZS_UINT64_STRLEN];
	char name_format[ZS_NAME_STRLEN];
	char tot_cpu[sizeof (ZSTAT_CPULINE)];
	char tot_mem[sizeof (ZSTAT_MEMLINE)];
	char tot_vm[sizeof (ZSTAT_VMLINE)];

	char *label;

	format_uint64(cpu, str_cpu, sizeof (str_cpu));
	format_uint64(online, str_online, sizeof (str_online));
	format_uint64(mem, str_mem, sizeof (str_mem));
	format_uint64(vm, str_vm, sizeof (str_vm));

	if (opt_parseable) {
		label = zonestat_get_plabel(report_fmt);
		(void) printf("%s:%s:[%s]:%s:%s:%s:%s\n", label,
		    ZONESTAT_SUMMARY, ZONESTAT_NAME_RESOURCE, str_cpu,
		    str_online, str_mem, str_vm);
		return;
	}

	(void) snprintf(tot_cpu, sizeof (tot_cpu), "Cpus/Online: %s/%s",
	    str_cpu, str_online);

	(void) snprintf(tot_mem, sizeof (tot_mem), "Physical: %s", str_mem);

	(void) snprintf(tot_vm, sizeof (tot_vm), "Virtual: %s", str_vm);

	/* Make first column as wide as longest zonename */
	(void) snprintf(name_format, sizeof (name_format), "%%-%ds ",
	    namewidth);
	/* LINTED */
	(void) printf(name_format, "SUMMARY");
	(void) printf(ZSTAT_SUM_HDR_FORMAT, tot_cpu, tot_mem,
	    tot_vm);

	/* LINTED */
	(void) printf(name_format, "");
	(void) printf(ZSTAT_SUM_HDR_FORMAT, ZSTAT_CPULINE,
	    ZSTAT_MEMLINE, ZSTAT_VMLINE);

	(void) snprintf(name_format, sizeof (name_format), "%%%ds ",
	    namewidth);
	/* LINTED */
	(void) printf(name_format, "ZONE");

	(void) printf(ZSTAT_SUM_ZONE_FORMAT, "USED", "%PART", "%CAP",
	    "%SHRU", "USED", "PCT", "%CAP", "USED", "PCT", "%CAP");
}

static void
zonestat_print_resource__header(size_t namelen, char *restype, char *size)
{
	char name_format[ZS_NAME_STRLEN];

	if (opt_parseable)
		return;

	(void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
	/* LINTED */
	(void) printf(name_format, restype);
	(void) printf(ZSTAT_RESOURCE_FORMAT, size);
}

static void
zonestat_print_resource_zone_header(size_t namelen)
{
	char name_format[ZS_NAME_STRLEN];

	if (opt_parseable)
		return;

	(void) snprintf(name_format, sizeof (name_format), "%%%ds ", namelen);
	/* LINTED */
	(void) printf(name_format, "ZONE");

	(void) printf(ZSTAT_RESOURCE_ZONE_FORMAT, "USED", "PCT", "CAP", "%CAP");
}

static void
zonestat_print_timestamp(time_t t)
{
	static char *fmt = NULL;
	int len;
	char dstr[64];

	/* We only need to retrieve this once per invocation */

	if (arg_timestamp == ZSTAT_UNIX_TIMESTAMP) {
		(void) printf("%ld", t);
	} else if (arg_timestamp == ZSTAT_ISO_TIMESTAMP) {

		len = strftime(dstr, sizeof (dstr), "%Y%m%dT%H%M%SZ",
		    gmtime(&t));
		if (len > 0)
			(void) printf("%s", dstr);

	} else {

		if (fmt == NULL)
			fmt = nl_langinfo(_DATE_FMT);

		len = strftime(dstr, sizeof (dstr), fmt, localtime(&t));
		if (len > 0)
			(void) printf("%s", dstr);
	}
}

static void
zonestat_print_summary_zone(size_t namewidth, int report_fmt, char *name,
    uint64_t cused, uint_t ppart, uint_t pccap, uint_t pshru, uint64_t mused,
    uint_t mpct, uint_t pmcap, uint64_t vused, uint_t vpct, uint_t pvcap)
{
	char *label;

	char str_cused[ZS_UINT64_STRLEN];
	char str_ppart[ZS_PCT_STRLEN];
	char str_pccap[ZS_PCT_STRLEN];
	char str_pshru[ZS_PCT_STRLEN];
	char str_mused[ZS_UINT64_STRLEN];
	char str_mpct[ZS_PCT_STRLEN];
	char str_pmcap[ZS_PCT_STRLEN];
	char str_vused[ZS_UINT64_STRLEN];
	char str_vpct[ZS_PCT_STRLEN];
	char str_pvcap[ZS_PCT_STRLEN];
	char name_format[ZS_NAME_STRLEN];

	format_cpu(cused, str_cused, sizeof (str_cused));
	format_pct(ppart, str_ppart, sizeof (str_ppart));
	format_pct(pccap, str_pccap, sizeof (str_pccap));
	format_pct(pshru, str_pshru, sizeof (str_pshru));
	format_uint64(mused, str_mused, sizeof (str_mused));
	format_pct(mpct, str_mpct, sizeof (str_mpct));
	format_pct(pmcap, str_pmcap, sizeof (str_pmcap));
	format_uint64(vused, str_vused, sizeof (str_vused));
	format_pct(vpct, str_vpct, sizeof (str_vpct));
	format_pct(pvcap, str_pvcap, sizeof (str_pvcap));

	if (opt_parseable) {
		if (opt_timestamp) {
			zonestat_print_timestamp(g_now_time);
			(void) printf(":");
		}
		label = zonestat_get_plabel(report_fmt);
		(void) printf("%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s\n",
		    label, ZONESTAT_SUMMARY, name, str_cused, str_ppart,
		    str_pccap, str_pshru, str_mused, str_mpct, str_pmcap,
		    str_vused, str_vpct, str_pvcap);
		return;
	}
	(void) snprintf(name_format, sizeof (name_format), "%%%ds ",
	    namewidth);
	/* LINTED */
	(void) printf(name_format, name);
	(void) printf(ZSTAT_SUM_ZONE_FORMAT, str_cused, str_ppart,
	    str_pccap, str_pshru, str_mused, str_mpct, str_pmcap, str_vused,
	    str_vpct, str_pvcap);
}

static void
zonestat_print_resource_(size_t namelen, int report_fmt, char *res,
    char *name, uint64_t size)
{
	char strsize[ZS_UINT64_STRLEN];
	char *label;
	char name_format[ZS_NAME_STRLEN];

	format_uint64(size, strsize, sizeof (strsize));
	if (opt_parseable) {
		if (opt_timestamp) {
			zonestat_print_timestamp(g_now_time);
			(void) printf(":");
		}
		label = zonestat_get_plabel(report_fmt);
		(void) printf("%s:%s:%s:[%s]:%s\n", label, res, name,
		    ZONESTAT_NAME_RESOURCE, strsize);
		return;
	}

	(void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
	/* LINTED */
	(void) printf(name_format, name);
	(void) printf(ZSTAT_RESOURCE_FORMAT, strsize);
}

static void
zonestat_print_resource_zone(size_t namelen, int report_fmt, char *restype,
    char *resname, char *name, uint64_t used, uint_t pct, uint64_t cap,
    uint_t pctcap)
{
	char strused[ZS_UINT64_STRLEN];
	char strpct[ZS_PCT_STRLEN];
	char strcap[ZS_UINT64_STRLEN];
	char strpctcap[ZS_PCT_STRLEN];
	char name_format[ZS_NAME_STRLEN];

	char *label;

	format_uint64(used, strused, sizeof (strused));
	format_pct(pct, strpct, sizeof (strpct));
	if (cap == ZS_LIMIT_NONE)
		(void) strlcpy(strcap, "-", sizeof (strcap));
	else
		format_uint64(cap, strcap, sizeof (strcap));

	if (pctcap == ZS_PCT_NONE)
		(void) strlcpy(strpctcap, "-", sizeof (strpctcap));
	else
		format_pct(pctcap, strpctcap, sizeof (strpctcap));

	if (opt_parseable) {
		if (opt_timestamp) {
			zonestat_print_timestamp(g_now_time);
			(void) printf(":");
		}
		label = zonestat_get_plabel(report_fmt);
		(void) printf("%s:%s:%s:%s:%s:%s:%s:%s\n", label, restype,
		    resname, name, strused, strpct, strcap, strpctcap);
		return;
	}

	(void) snprintf(name_format, sizeof (name_format), "%%%ds ", namelen);
	/* LINTED */
	(void) printf(name_format, name);
	(void) printf(ZSTAT_RESOURCE_ZONE_FORMAT, strused, strpct, strcap,
	    strpctcap);
}

/*
 * Not thread safe.
 */
static void
zonestat_qsort(void *base, size_t nel, size_t width,
    int (*compar)(const void *, const void *), int by)
{
	g_sort_by = by;
	g_max_zonename = 0;
	qsort(base, nel, width, compar);
}

static int
zonestat_zone_compare_resource(const void *a, const void *b)
{
	zs_zone_t *zonea = *(zs_zone_t **)a;
	zs_zone_t *zoneb = *(zs_zone_t **)b;
	zs_property_t *prop, *propb;
	uint64_t resa, resb;
	uint_t uinta, uintb;
	int i, res;

	prop = alloca(zs_property_size());
	propb = alloca(zs_property_size());

	for (i = 0; i < arg_sort_count; i++) {

		/* Sort by order of selection */
		switch (g_sorts[i]) {
		case ZSTAT_SORT_USED:
			resa = zs_resource_used_zone_uint64(zonea, g_sort_by);
			resb = zs_resource_used_zone_uint64(zoneb, g_sort_by);
			break;
		case ZSTAT_SORT_CAP:
			resa = zs_zone_limit_uint64(zonea, g_sort_by);
			if (resa == ZS_LIMIT_NONE)
				resa = 0;
			resb = zs_zone_limit_uint64(zoneb, g_sort_by);
			if (resb == ZS_LIMIT_NONE)
				resb = 0;
			break;
		case ZSTAT_SORT_PCAP:
			uinta = zs_zone_limit_used_pct(zonea, g_sort_by);
			uintb = zs_zone_limit_used_pct(zoneb, g_sort_by);
			if (uinta == ZS_PCT_NONE)
				resa = 0;
			else
				resa = uinta;
			if (uintb == ZS_PCT_NONE)
				resb = 0;
			else
				resb = uintb;
			break;
		case ZSTAT_SORT_SHR:
			zs_zone_property(zonea, ZS_PZ_PROP_CPU_SHARES, prop);
			resa = zs_property_uint64(prop);
			if (resa == ZS_LIMIT_NONE)
				resa = 0;
			zs_zone_property(zoneb, ZS_PZ_PROP_CPU_SHARES, prop);
			resb = zs_property_uint64(prop);
			if (resb == ZS_LIMIT_NONE)
				resb = 0;
			break;
		case ZSTAT_SORT_PSHRU:
			uinta = zs_zone_limit_used_pct(zonea,
			    ZS_LIMIT_CPU_SHARES);
			uintb = zs_zone_limit_used_pct(zoneb,
			    ZS_LIMIT_CPU_SHARES);
			if (uinta == ZS_PCT_NONE)
				resa = 0;
			else
				resa = uinta;
			if (uintb == ZS_PCT_NONE)
				resb = 0;
			else
				resb = uintb;
			break;
		case ZSTAT_SORT_NAME:
			zs_zone_property(zonea, ZS_ZONE_PROP_NAME, prop);
			zs_zone_property(zoneb, ZS_ZONE_PROP_NAME, propb);

			res = strcmp(zs_property_string(prop),
			    zs_property_string(propb));
			if (res != 0)
				return (res);
			break;
		default:
			exit(zonestat_error(gettext("Internal sort error")));
		}
		if (resa < resb)
			return (1);
		if (resb < resa)
			return (-1);
	}
	/* No difference, return 0 */
	return (0);
}
/*
 * Sort psets.  Default pset first, then shared psets, then dedicated
 * psets.
 */
static int
zonestat_pset_compare(const void *a, const void *b)
{
	zs_pset_t *pseta = *(zs_pset_t **)a;
	zs_pset_t *psetb = *(zs_pset_t **)b;
	zs_property_t *p;
	uint_t typea, typeb;


	p = (zs_property_t *)alloca(zs_property_size());
	zs_pset_property(pseta, ZS_PSET_PROP_CPUTYPE, p);
	typea = zs_property_uint(p);
	zs_pset_property(psetb, ZS_PSET_PROP_CPUTYPE, p);
	typeb = zs_property_uint(p);

	if (typea == ZS_CPUTYPE_DEFAULT_PSET)
		return (-1);
	if (typeb == ZS_CPUTYPE_DEFAULT_PSET)
		return (1);
	if (typea == ZS_CPUTYPE_POOL_PSET)
		return (-1);
	if (typeb == ZS_CPUTYPE_POOL_PSET)
		return (1);
	if (typea == ZS_CPUTYPE_PSRSET_PSET)
		return (-1);
	if (typeb == ZS_CPUTYPE_PSRSET_PSET)
		return (1);

	return (0);
}

static int
zonestat_pz_compare_usage(const void *a, const void *b)
{
	zs_pset_zone_t *zonea = *(zs_pset_zone_t **)a;
	zs_pset_zone_t *zoneb = *(zs_pset_zone_t **)b;
	zs_property_t *prop, *propb;
	uint64_t resa, resb;
	uint_t uinta, uintb;
	int i, res;

	prop = alloca(zs_property_size());
	propb = alloca(zs_property_size());

	for (i = 0; i < arg_sort_count; i++) {

		/* Sort by order of selection */
		switch (g_sorts[i]) {
		case ZSTAT_SORT_USED:
			resa = zs_pset_zone_used_cpus(zonea);
			resb = zs_pset_zone_used_cpus(zoneb);
			break;
		case ZSTAT_SORT_CAP:
			zs_pset_zone_property(zonea, ZS_PZ_PROP_CPU_CAP,
			    prop);
			resa = zs_property_uint64(prop);
			if (resa == ZS_LIMIT_NONE)
				resa = 0;
			zs_pset_zone_property(zoneb, ZS_PZ_PROP_CPU_CAP,
			    prop);
			resb = zs_property_uint64(prop);
			if (resb == ZS_LIMIT_NONE)
				resb = 0;
			break;
		case ZSTAT_SORT_PCAP:
			uinta = zs_pset_zone_used_pct(zonea, ZS_PZ_PCT_CPU_CAP);
			uintb = zs_pset_zone_used_pct(zoneb, ZS_PZ_PCT_CPU_CAP);
			if (uinta == ZS_PCT_NONE)
				resa = 0;
			else
				resa = uinta;
			if (uintb == ZS_PCT_NONE)
				resb = 0;
			else
				resb = uintb;
			break;
		case ZSTAT_SORT_SHR:
			zs_pset_zone_property(zonea, ZS_PZ_PROP_CPU_SHARES,
			    prop);
			resa = zs_property_uint64(prop);
			if (resa == ZS_LIMIT_NONE)
				resa = 0;
			zs_pset_zone_property(zoneb, ZS_PZ_PROP_CPU_SHARES,
			    prop);
			resb = zs_property_uint64(prop);
			if (resb == ZS_LIMIT_NONE)
				resb = 0;
			break;
		case ZSTAT_SORT_PSHRU:
			uinta = zs_pset_zone_used_pct(zonea,
			    ZS_PZ_PCT_CPU_SHARES);
			uintb = zs_pset_zone_used_pct(zoneb,
			    ZS_PZ_PCT_CPU_SHARES);
			if (uinta == ZS_PCT_NONE)
				resa = 0;
			else
				resa = uinta;
			if (uintb == ZS_PCT_NONE)
				resb = 0;
			else
				resb = uintb;
			break;
		case ZSTAT_SORT_NAME:
			zs_zone_property(zs_pset_zone_get_zone(zonea),
			    ZS_ZONE_PROP_NAME, prop);
			zs_zone_property(zs_pset_zone_get_zone(zoneb),
			    ZS_ZONE_PROP_NAME, propb);

			res = strcmp(zs_property_string(prop),
			    zs_property_string(propb));
			if (res != 0)
				return (res);
			break;
		default:
			exit(zonestat_error(gettext("Internal sort error")));
		}
		if (resa < resb)
			return (1);
		if (resb < resa)
			return (-1);
	}
	/* No difference, return 0 */
	return (0);
}


static void
zonestat_print_summary(int report_fmt, zs_usage_t *u)
{
	int num, i;
	zs_zone_t *z;
	uint64_t cpus, online, tot_mem, tot_vm;
	uint64_t cused, mused, vused;
	uint_t ppart, pshru, pccap, mpct, pmcap, vpct, pvcap;
	char zonename[ZS_ZONENAME_MAX];
	zs_property_t *prop;
	size_t namewidth = 0, len;

	prop = (zs_property_t *)alloca(zs_property_size());

	zs_resource_property(u, ZS_RESOURCE_CPU, ZS_RESOURCE_PROP_CPU_TOTAL,
	    prop);
	cpus = zs_property_uint64(prop);

	zs_resource_property(u, ZS_RESOURCE_CPU,
	    ZS_RESOURCE_PROP_CPU_ONLINE, prop);
	online = zs_property_uint64(prop);

	tot_mem = zs_resource_total_uint64(u, ZS_RESOURCE_RAM_RSS);
	tot_vm = zs_resource_total_uint64(u, ZS_RESOURCE_VM);

again:
	num = zs_zone_list(u, g_zone_list, g_zone_num);
	if (num > g_zone_num) {
		if (g_zone_list != NULL)
			free(g_zone_list);
		g_zone_list = (zs_zone_t **) malloc(sizeof (zs_zone_t *) * num);
		g_zone_num = num;
		goto again;
	}

	/* Find the longest zone name to set output width. */
	namewidth = ZSTAT_SUM_MIN_ZONENAME;
	for (i = 0; i < num; i++) {
		z = g_zone_list[i];
		(void) zs_zone_property(z, ZS_ZONE_PROP_NAME, prop);
		len = strlen(zs_property_string(prop));
		if (len > namewidth)
			namewidth = len;
	}
	zonestat_print_summary_header(namewidth, report_fmt, cpus, online,
	    tot_mem, tot_vm);

	zonestat_qsort(g_zone_list, num, sizeof (zs_zone_t *),
	    zonestat_zone_compare_resource, g_sort_summary);

	cused = zs_resource_used_uint64(u, ZS_RESOURCE_CPU, ZS_USER_ALL);
	mused = zs_resource_used_uint64(u, ZS_RESOURCE_RAM_RSS, ZS_USER_ALL);
	vused = zs_resource_used_uint64(u, ZS_RESOURCE_VM, ZS_USER_ALL);

	ppart = zs_resource_used_pct(u, ZS_RESOURCE_CPU, ZS_USER_ALL);
	mpct = zs_resource_used_pct(u, ZS_RESOURCE_RAM_RSS, ZS_USER_ALL);
	vpct = zs_resource_used_pct(u, ZS_RESOURCE_VM, ZS_USER_ALL);

	if (opt_line_total) {
		(void) snprintf(zonename, sizeof (zonename), "[%s]",
		    ZONESTAT_NAME_TOTAL);
		zonestat_print_summary_zone(namewidth, report_fmt, zonename,
		    cused, ppart, ZS_PCT_NONE, ZS_PCT_NONE, mused, mpct,
		    ZS_PCT_NONE, vused, vpct, ZS_PCT_NONE);
	}
	cused = zs_resource_used_uint64(u, ZS_RESOURCE_CPU, ZS_USER_KERNEL);
	mused = zs_resource_used_uint64(u, ZS_RESOURCE_RAM_RSS, ZS_USER_KERNEL);
	vused = zs_resource_used_uint64(u, ZS_RESOURCE_VM, ZS_USER_KERNEL);

	ppart = zs_resource_used_pct(u, ZS_RESOURCE_CPU, ZS_USER_KERNEL);
	mpct = zs_resource_used_pct(u, ZS_RESOURCE_RAM_RSS, ZS_USER_KERNEL);
	vpct = zs_resource_used_pct(u, ZS_RESOURCE_VM, ZS_USER_KERNEL);

	if (opt_line_system) {
		(void) snprintf(zonename, sizeof (zonename), "[%s]",
		    ZONESTAT_NAME_SYSTEM);
		zonestat_print_summary_zone(namewidth, report_fmt, zonename,
		    cused, ppart, ZS_PCT_NONE, ZS_PCT_NONE, mused, mpct,
		    ZS_PCT_NONE, vused, vpct, ZS_PCT_NONE);
	}
	for (i = 0; i < num; i++) {

		z = g_zone_list[i];

		zs_zone_property(z, ZS_ZONE_PROP_NAME, prop);
		(void) strlcpy(zonename, zs_property_string(prop),
		    sizeof (zonename));

		cused = zs_resource_used_zone_uint64(z, ZS_RESOURCE_CPU);
		mused = zs_resource_used_zone_uint64(z, ZS_RESOURCE_RAM_RSS);
		vused = zs_resource_used_zone_uint64(z, ZS_RESOURCE_VM);

		ppart = zs_resource_used_zone_pct(z, ZS_RESOURCE_CPU);
		mpct = zs_resource_used_zone_pct(z, ZS_RESOURCE_RAM_RSS);
		vpct = zs_resource_used_zone_pct(z, ZS_RESOURCE_VM);

		pshru = zs_zone_limit_used_pct(z, ZS_LIMIT_CPU_SHARES);
		pccap = zs_zone_limit_used_pct(z, ZS_LIMIT_CPU);
		pmcap = zs_zone_limit_used_pct(z, ZS_LIMIT_RAM_RSS);
		pvcap = zs_zone_limit_used_pct(z, ZS_LIMIT_VM);

		zonestat_print_summary_zone(namewidth, report_fmt, zonename,
		    cused, ppart, pccap, pshru, mused, mpct, pmcap, vused, vpct,
		    pvcap);
	}

	if (!opt_parseable)
		(void) printf("\n");
	(void) fflush(stdout);
}

static void
zonestat_print_res(int report_fmt, char *header, char *sizename, char *resname,
    char *name, zs_usage_t *u, int res, int limit)
{
	zs_zone_t *zone;
	char zonename[ZS_ZONENAME_MAX];
	uint64_t size;
	uint64_t used;
	uint64_t cap;
	uint_t pct;
	uint_t pctcap;
	zs_property_t *prop;
	int num, i;
	size_t namelen, len;

	prop = (zs_property_t *)alloca(zs_property_size());

	/* See if resource matches specified resource names */
	if (zonestat_match_resname(name) == 0)
		return;

	namelen = strlen(resname);
	if (ZSTAT_RESOURCE_MIN_RESNAME > namelen)
		namelen = ZSTAT_RESOURCE_MIN_RESNAME;

	zonestat_print_resource__header(namelen, header, sizename);

	size = zs_resource_total_uint64(u, res);

	if (opt_line_resource)
		zonestat_print_resource_(namelen, report_fmt, resname, name,
		    size);

again:
	num = zs_zone_list(u, g_zone_list, g_zone_num);
	if (num > g_zone_num) {
		if (g_zone_list != NULL)
			free(g_zone_list);
		g_zone_list = (zs_zone_t **) malloc(sizeof (zs_zone_t *) * num);
		g_zone_num = num;
		goto again;
	}
	namelen = ZSTAT_RESOURCE_MIN_ZONENAME;
	for (i = 0; i < num; i++) {
		zone = g_zone_list[i];
		(void) zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
		len = strlen(zs_property_string(prop));
		if (len > namelen)
			namelen = len;
	}

	zonestat_print_resource_zone_header(namelen);

	used = zs_resource_used_uint64(u, res, ZS_USER_ALL);
	pct = zs_resource_used_pct(u, res, ZS_USER_ALL);

	if (opt_line_total) {
		(void) snprintf(zonename, sizeof (zonename), "[%s]",
		    ZONESTAT_NAME_TOTAL);
		zonestat_print_resource_zone(namelen, report_fmt, resname,
		    name, zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE);
	}
	used = zs_resource_used_uint64(u, res, ZS_USER_KERNEL);
	pct = zs_resource_used_pct(u, res, ZS_USER_KERNEL);

	if (opt_line_system) {
		(void) snprintf(zonename, sizeof (zonename), "[%s]",
		    ZONESTAT_NAME_SYSTEM);
		zonestat_print_resource_zone(namelen, report_fmt, resname, name,
		    zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE);
	}
	zonestat_qsort(g_zone_list, num, sizeof (zs_zone_t *),
	    zonestat_zone_compare_resource, res);

	for (i = 0; i < num; i++) {

		zone = g_zone_list[i];
		zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
		(void) strlcpy(zonename, zs_property_string(prop),
		    sizeof (zonename));

		if (zonestat_match_zonename(zonename) == 0)
			continue;

		used = zs_resource_used_zone_uint64(zone, res);
		pct = zs_resource_used_zone_pct(zone, res);

		cap = zs_zone_limit_uint64(zone, limit);
		pctcap = zs_zone_limit_used_pct(zone, limit);

		if (opt_line_zones)
			zonestat_print_resource_zone(namelen, report_fmt,
			    resname, name, zonename, used, pct, cap, pctcap);
	}
	if (!opt_parseable)
		(void) printf("\n");
}

static void
zonestat_print_cpu_res_header(size_t namelen)
{
	char name_format[ZS_NAME_STRLEN];

	if (opt_parseable)
		return;

	(void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
	/* LINTED */
	(void) printf(name_format, "PROCESSOR_SET");
	(void) printf(ZSTAT_CPU_RES_FORMAT, "TYPE", "ONLINE/CPUS", "MIN/MAX");
}
static void
zonestat_print_cpu_zone_header(size_t namelen)
{
	char name_format[ZS_NAME_STRLEN];

	if (opt_parseable)
		return;

	(void) snprintf(name_format, sizeof (name_format), "%%%ds ", namelen);
	/* LINTED */
	(void) printf(name_format, "ZONE");

	(void) printf(ZSTAT_CPU_ZONE_FORMAT, "USED", "PCT", "CAP",
	    "%CAP", "SHRS", "%SHR", "%SHRU");
}

static void
zonestat_print_cpu_res(size_t namelen, int report_fmt, char *cputype,
    char *name, uint64_t online, uint64_t size, uint64_t min, uint64_t max,
    timestruc_t *ts)
{
	char online_str[ZS_UINT64_STRLEN];
	char size_str[ZS_UINT64_STRLEN];
	char min_str[ZS_UINT64_STRLEN];
	char max_str[ZS_UINT64_STRLEN];
	char cpus_str[ZS_UINT64_STRLEN + ZS_UINT64_STRLEN + 1];
	char minmax_str[ZS_UINT64_STRLEN + ZS_UINT64_STRLEN + 1];
	char ts_str[ZS_TIME_STRLEN];
	char name_format[ZS_NAME_STRLEN];

	char *label;

	format_uint64(online, online_str, sizeof (online_str));
	format_uint64(size, size_str, sizeof (size_str));
	format_uint64(min, min_str, sizeof (min_str));
	format_uint64(max, max_str, sizeof (max_str));
	format_ts(ts, ts_str, sizeof (ts_str), B_FALSE);

	if (opt_parseable) {
		if (opt_timestamp) {
			zonestat_print_timestamp(g_now_time);
			(void) printf(":");
		}
		label = zonestat_get_plabel(report_fmt);

		(void) printf("%s:%s:%s:%s:[%s]:%s:%s:%s:%s:%s\n", label,
		    ZONESTAT_PROCESSOR_SET, cputype, name,
		    ZONESTAT_NAME_RESOURCE, online_str, size_str, min_str,
		    max_str, ts_str);
		return;
	}

	(void) snprintf(cpus_str, sizeof (cpus_str), "%s/%s", online_str,
	    size_str);
	(void) snprintf(minmax_str, sizeof (minmax_str), "%s/%s", min_str,
	    max_str);

	(void) snprintf(name_format, sizeof (name_format), "%%-%ds ", namelen);
	/* LINTED */
	(void) printf(name_format, name);
	(void) printf(ZSTAT_CPU_RES_FORMAT, cputype, cpus_str, minmax_str);
}

static void
zonestat_print_cpu_zone(size_t namelen, int report_fmt, char *cputype,
    char *name, char *zonename, uint64_t used, uint_t pct, uint64_t cap,
    uint_t pct_cap, uint64_t shares, uint_t scheds, uint_t pct_shares,
    uint_t pct_shares_used, timestruc_t *ts, boolean_t report_conflict)
{
	char used_str[ZS_UINT64_STRLEN];
	char pct_str[ZS_PCT_STRLEN];
	char cap_str[ZS_UINT64_STRLEN];
	char pct_cap_str[ZS_PCT_STRLEN];
	char shares_str[ZS_UINT64_STRLEN];
	char pct_shares_str[ZS_PCT_STRLEN];
	char pct_shares_used_str[ZS_PCT_STRLEN];
	char ts_str[ZS_TIME_STRLEN];
	char name_format[ZS_NAME_STRLEN];
	char *label;

	format_cpu(used, used_str, sizeof (used_str));
	format_pct(pct, pct_str, sizeof (pct_str));
	format_ts(ts, ts_str, sizeof (ts_str), B_FALSE);

	if (cap == ZS_LIMIT_NONE)
		(void) strlcpy(cap_str, "-", sizeof (cap_str));
	else
		format_cpu(cap, cap_str, sizeof (cap_str));

	if (pct_cap == ZS_PCT_NONE)
		(void) strlcpy(pct_cap_str, "-", sizeof (pct_cap_str));
	else
		format_pct(pct_cap, pct_cap_str, sizeof (pct_cap_str));

	if ((scheds & ZS_SCHED_CONFLICT) &&
	    (!(scheds & ZS_SCHED_FSS)))
		(void) strlcpy(shares_str, "no-fss", sizeof (shares_str));
	else if (shares == ZS_LIMIT_NONE)
		(void) strlcpy(shares_str, "-", sizeof (shares_str));
	else if (shares == ZS_SHARES_UNLIMITED)
		(void) strlcpy(shares_str, "inf", sizeof (shares_str));
	else
		format_uint64(shares, shares_str, sizeof (shares_str));

	if (pct_shares == ZS_PCT_NONE)
		(void) strlcpy(pct_shares_str, "-", sizeof (pct_shares_str));
	else
		format_pct(pct_shares, pct_shares_str,
		    sizeof (pct_shares_str));

	if (pct_shares_used == ZS_PCT_NONE) {
		(void) strlcpy(pct_shares_used_str, "-",
		    sizeof (pct_shares_used_str));
	} else {
		format_pct(pct_shares_used, pct_shares_used_str,
		    sizeof (pct_shares_used_str));
	}
	if (opt_parseable) {
		if (opt_timestamp) {
			zonestat_print_timestamp(g_now_time);
			(void) printf(":");
		}
		label = zonestat_get_plabel(report_fmt);

		(void) printf("%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s\n", label,
		    ZONESTAT_PROCESSOR_SET, cputype, name, zonename, used_str,
		    pct_str, cap_str, pct_cap_str, shares_str, pct_shares_str,
		    pct_shares_used_str, ts_str);
		return;
	} else {
		(void) snprintf(name_format, sizeof (name_format), "%%%ds ",
		    namelen);
		/* LINTED */
		(void) printf(name_format, zonename);

		(void) printf(ZSTAT_CPU_ZONE_FORMAT, used_str,
		    pct_str, cap_str, pct_cap_str, shares_str, pct_shares_str,
		    pct_shares_used_str);
	}
	/* Report if zone has mix of schedulers conflicting with FSS */
	if (report_conflict && (scheds & ZS_SCHED_CONFLICT) &&
	    (scheds & ZS_SCHED_FSS)) {
		/* LINTED */
		(void) printf(name_format, "");
		(void) printf(" mixed schedulers found:");
		(void) printf(" FSS");
		if (scheds & ZS_SCHED_TS)
			(void) printf(", TS");
		if (scheds & ZS_SCHED_IA)
			(void) printf(", IA");
		if (scheds & ZS_SCHED_FX)
			(void) printf(", FX");
		(void) printf("\n");
	}
}

static void
zonestat_print_pset(int report_fmt, zs_pset_t *pset, char *cputype)
{
	zs_pset_zone_t *pz;
	zs_zone_t *zone;
	uint64_t cpus;
	uint64_t size;
	uint64_t min;
	uint64_t max;
	uint_t scheds;
	uint64_t used;
	uint_t pct;
	uint64_t cap;
	uint_t pct_cap;
	uint64_t shares;
	uint_t pct_shares;
	uint_t pct_shares_used;
	char psetname[ZS_PSETNAME_MAX];
	char zonename[ZS_PSETNAME_MAX];
	char *name;
	zs_property_t *prop;
	boolean_t zone_match;
	int num, i;
	timestruc_t ts;
	size_t namelen, len;

	prop = (zs_property_t *)alloca(zs_property_size());

	zs_pset_property(pset, ZS_PSET_PROP_NAME, prop);
	(void) strlcpy(psetname, zs_property_string(prop), sizeof (psetname));

	/* Check if pset contains specified zone */
	if (arg_zonename_count > 0) {
		zone_match = B_FALSE;
		for (pz = zs_pset_zone_first(pset); pz != NULL;
		    pz = zs_pset_zone_next(pset, pz)) {
			zone = zs_pset_zone_get_zone(pz);
			(void) zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
			(void) strlcpy(zonename, zs_property_string(prop),
			    sizeof (zonename));

			if (zonestat_match_zonename(zonename) == 1) {
				zone_match = B_TRUE;
				break;
			}
		}
		if (zone_match == B_FALSE)
			return;
	}

	if (zonestat_match_resname(psetname) == 0)
		return;

	zs_pset_property(pset, ZS_PSET_PROP_ONLINE, prop);
	cpus = zs_property_uint64(prop);
	zs_pset_property(pset, ZS_PSET_PROP_SIZE, prop);
	size = zs_property_uint64(prop);
	zs_pset_property(pset, ZS_PSET_PROP_MIN, prop);
	min = zs_property_uint64(prop);
	zs_pset_property(pset, ZS_PSET_PROP_MAX, prop);
	max = zs_property_uint64(prop);
	zs_pset_total_time(pset, &ts);

	/* Strip off SUNWtmp_ from pset name */
	name = psetname;
	if (strncmp(psetname, "SUNWtmp_", strlen("SUNWtmp_")) == 0) {
		name = strchr(psetname, '_');
		name++;
	}

	/* Strip off SUNWlegacy_pst for psrset psets */
	if (strncmp(psetname, "SUNWlegacy_pset_",
	    strlen("SUNWlegacy_pset_")) == 0) {
		name = strrchr(psetname, '_');
		name++;
	}

	namelen = strlen(name);
	if (ZSTAT_CPU_MIN_PSETNAME > namelen)
		namelen = ZSTAT_CPU_MIN_PSETNAME;

	zonestat_print_cpu_res_header(namelen);

	if (opt_line_resource)
		zonestat_print_cpu_res(namelen, report_fmt, cputype, name, cpus,
		    size, min, max, &ts);

again:
	num = zs_pset_zone_list(pset, g_pz_list, g_pz_num);
	if (num > g_pz_num) {
		if (g_pz_list != NULL)
			free(g_pz_list);
		g_pz_list = (zs_pset_zone_t **)malloc(
		    sizeof (zs_pset_zone_t *) * num);
		g_pz_num = num;
		goto again;
	}

	/* Find longest zone name in pset */
	namelen = ZSTAT_CPU_MIN_ZONENAME;
	for (i = 0; i < num; i++) {
		pz = g_pz_list[i];
		zone = zs_pset_zone_get_zone(pz);
		zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
		len = strlen(zs_property_string(prop));
		if (len > namelen)
			namelen = len;
	}

	qsort(g_pz_list, num, sizeof (zs_pset_zone_t *),
	    zonestat_pz_compare_usage);

	zonestat_print_cpu_zone_header(namelen);

	zs_pset_property(pset, ZS_PSET_PROP_CPU_SHARES, prop);
	shares = zs_property_uint64(prop);
	zs_pset_property(pset, ZS_PSET_PROP_SCHEDULERS, prop);
	scheds = zs_property_uint(prop);

	zs_pset_used_time(pset, ZS_USER_ALL, &ts);
	used = zs_pset_used_cpus(pset, ZS_USER_ALL);
	pct = zs_pset_used_pct(pset, ZS_USER_ALL);

	if (opt_line_total) {
		(void) snprintf(zonename, sizeof (zonename), "[%s]",
		    ZONESTAT_NAME_TOTAL);
		zonestat_print_cpu_zone(namelen, report_fmt, cputype, name,
		    zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE, shares,
		    scheds, ZS_PCT_NONE, ZS_PCT_NONE, &ts, B_FALSE);
	}
	zs_pset_used_time(pset, ZS_USER_KERNEL, &ts);
	used = zs_pset_used_cpus(pset, ZS_USER_KERNEL);
	pct = zs_pset_used_pct(pset, ZS_USER_KERNEL);

	if (opt_line_system) {
		(void) snprintf(zonename, sizeof (zonename), "[%s]",
		    ZONESTAT_NAME_SYSTEM);
		zonestat_print_cpu_zone(namelen, report_fmt, cputype, name,
		    zonename, used, pct, ZS_LIMIT_NONE, ZS_PCT_NONE,
		    ZS_LIMIT_NONE, 0, ZS_PCT_NONE, ZS_PCT_NONE, &ts, B_FALSE);
	}
	for (i = 0; i < num; i++) {

		pz = g_pz_list[i];
		zone = zs_pset_zone_get_zone(pz);
		zs_zone_property(zone, ZS_ZONE_PROP_NAME, prop);
		(void) strlcpy(zonename, zs_property_string(prop),
		    sizeof (zonename));

		if (zonestat_match_zonename(zonename) == 0)
			continue;

		zs_pset_zone_property(pz, ZS_PZ_PROP_CPU_CAP, prop);
		cap = zs_property_uint64(prop);

		zs_pset_zone_property(pz, ZS_PZ_PROP_CPU_SHARES, prop);
		shares = zs_property_uint64(prop);
		zs_pset_zone_property(pz, ZS_PZ_PROP_SCHEDULERS, prop);
		scheds = zs_property_uint(prop);

		used = zs_pset_zone_used_cpus(pz);
		zs_pset_zone_used_time(pz, &ts);
		pct = zs_pset_zone_used_pct(pz, ZS_PZ_PCT_PSET);
		pct_cap = zs_pset_zone_used_pct(pz, ZS_PZ_PCT_CPU_CAP);
		pct_shares = zs_pset_zone_used_pct(pz, ZS_PZ_PCT_PSET_SHARES);
		pct_shares_used = zs_pset_zone_used_pct(pz,
		    ZS_PZ_PCT_CPU_SHARES);

		if (opt_line_zones)
			zonestat_print_cpu_zone(namelen, report_fmt, cputype,
			    name, zonename, used, pct, cap, pct_cap, shares,
			    scheds, pct_shares, pct_shares_used, &ts, B_TRUE);
	}
	if (!opt_parseable)
		(void) printf("\n");
}

/* ARGSUSED */
static void
zonestat_quithandler(int sig)
{
	g_quit = B_TRUE;
}

static void
zonestat_print_footer(int report_fmt)
{
	char *label;

	if (!opt_parseable)
		return;

	if (opt_timestamp) {
		zonestat_print_timestamp(g_now_time);
		(void) printf(":");
	}
	label = zonestat_get_plabel(report_fmt);
	(void) printf("%s:%s:", label, ZONESTAT_NAME_FOOTER);
	zonestat_print_timestamp(g_now_time);
	(void) printf("%d:%ld\n", g_interval, g_seconds);
	(void) fflush(stdout);
}

static void
zonestat_print_header(int report_fmt)
{
	char *label;
	timestruc_t ts;
	char string[ZS_TIME_STRLEN];

	if (!opt_parseable) {

		/* Human readable header */
		if (opt_timestamp) {
			zonestat_print_timestamp(g_now_time);
			(void) printf(", ");
		}
		if (report_fmt == ZSTAT_REPORT_FMT_INTERVAL) {
			ts.tv_sec = g_seconds;
			ts.tv_nsec = 0;
			format_ts(&ts, string, sizeof (string), B_TRUE);
			(void) printf("Interval: %d, Duration: %s\n", g_count,
			    string);
			(void) fflush(stdout);
			return;
		} else {
			switch (report_fmt) {
			case ZSTAT_REPORT_FMT_TOTAL:
				label = "Report: Total Usage";
				break;
			case ZSTAT_REPORT_FMT_AVERAGE:
				label = "Report: Average Usage";
				break;
			case ZSTAT_REPORT_FMT_HIGH:
				label = "Report: High Usage";
				break;
			default:
				exit(zonestat_error(gettext(
				    "Internal error, invalid header")));
			}
			/* Left are the report header formats */
			(void) printf("%s\n", label);
			(void) printf("    Start: ");
			zonestat_print_timestamp(g_start_time);
			(void) printf("\n      End: ");
			zonestat_print_timestamp(g_end_time);
			(void) printf("\n");
			ts.tv_sec = g_seconds;
			ts.tv_nsec = 0;
			format_ts(&ts, string, sizeof (string), B_TRUE);
			(void) printf("    Intervals: %d, Duration: %s\n",
			    g_count, string);

			(void) fflush(stdout);
			return;
		}
	}

	if (!opt_line_header)
		return;

	/* Parseable header */
	if (opt_timestamp) {
		zonestat_print_timestamp(g_now_time);
		(void) printf(":");
	}
	label = zonestat_get_plabel(report_fmt);

	(void) printf("%s:%s:", label, ZONESTAT_NAME_HEADER);
	if (report_fmt == ZSTAT_REPORT_FMT_INTERVAL) {
		(void) printf("since-last-interval:");
		zonestat_print_timestamp(g_now_time);
		(void) printf(":%d:%ld\n", g_count, g_seconds);
		(void) fflush(stdout);
		return;
	}

	/* Left are the report header formats */
	zonestat_print_timestamp(g_start_time);
	(void) printf(":");
	zonestat_print_timestamp(g_end_time);
	(void) printf(":");
	(void) printf("%d:%ld\n", g_interval, g_seconds);
	(void) fflush(stdout);
}

static void
zonestat_print_psets(int report_fmt, zs_usage_t *u)
{
	zs_pset_t *pset;
	char *psettype;
	uint_t cputype, num, i;
	zs_property_t *p;

again:
	num = zs_pset_list(u, g_pset_list, g_pset_num);
	if (num > g_pset_num) {
		if (g_pset_list != NULL)
			free(g_pset_list);
		g_pset_list = (zs_pset_t **)malloc(
		    sizeof (zs_pset_t *) * num);
		g_pset_num = num;
		goto again;
	}

	/* Sort, default pset first, then pool, psrset, and dedicated psets */
	qsort(g_pset_list, num, sizeof (zs_pset_t *), zonestat_pset_compare);

	p = (zs_property_t *)alloca(zs_property_size());
	for (i = 0; i < num; i++) {
		pset = g_pset_list[i];
		(void) zs_pset_property(pset, ZS_PSET_PROP_CPUTYPE, p);
		cputype = zs_property_uint(p);
		if (cputype == ZS_CPUTYPE_DEFAULT_PSET &&
		    (g_resources & (ZSTAT_RES_PSETS |
		    ZSTAT_RES_DEFAULT_PSET))) {
			psettype = ZONESTAT_DEFAULT_PSET;
		} else if (cputype == ZS_CPUTYPE_POOL_PSET &&
		    (g_resources & ZSTAT_RES_PSETS)) {
			psettype = ZONESTAT_POOL_PSET;
		} else if (cputype == ZS_CPUTYPE_PSRSET_PSET &&
		    (g_resources & ZSTAT_RES_PSETS)) {
			psettype = ZONESTAT_PSRSET_PSET;
		} else if (cputype == ZS_CPUTYPE_DEDICATED &&
		    (g_resources & ZSTAT_RES_PSETS)) {
			psettype = ZONESTAT_DEDICATED_CPU;
		} else {
			continue;
		}
		zonestat_print_pset(report_fmt, pset, psettype);
	}
}

static void
zonestat_print_resources(int report_fmt, zs_usage_t *usage)
{
	if (g_resources & ZSTAT_RES_SUMMARY)
		zonestat_print_summary(report_fmt, usage);

	if (g_resources & ZSTAT_RES_PHYSICAL_MEMORY)
		zonestat_print_res(report_fmt, "PHYSICAL-MEMORY",
		    "SYSTEM MEMORY", ZONESTAT_PHYSICAL_MEMORY,
		    ZONESTAT_NAME_MEM_DEFAULT, usage,
		    ZS_RESOURCE_RAM_RSS, ZS_LIMIT_RAM_RSS);
	if (g_resources & ZSTAT_RES_VIRTUAL_MEMORY)
		zonestat_print_res(report_fmt, "VIRTUAL-MEMORY",
		    "SYSTEM MEMORY", ZONESTAT_VIRTUAL_MEMORY,
		    ZONESTAT_NAME_VM_DEFAULT, usage,
		    ZS_RESOURCE_VM, ZS_LIMIT_VM);
	if (g_resources & ZSTAT_RES_LOCKED_MEMORY)
		zonestat_print_res(report_fmt, "LOCKED-MEMORY", "SYSTEM MEMORY",
		    ZONESTAT_LOCKED_MEMORY, ZONESTAT_NAME_MEM_DEFAULT, usage,
		    ZS_RESOURCE_RAM_LOCKED, ZS_LIMIT_RAM_LOCKED);

	if (g_resources & (ZSTAT_RES_PSETS | ZSTAT_RES_DEFAULT_PSET))
			zonestat_print_psets(report_fmt, usage);

	if (g_resources & ZSTAT_RES_PROCESSES)
		zonestat_print_res(report_fmt, "PROCESSES", "SYSTEM LIMIT",
		    ZONESTAT_PROCESSES, ZONESTAT_NAME_SYSTEM_LIMIT,
		    usage, ZS_RESOURCE_PROCESSES, ZS_LIMIT_PROCESSES);

	if (g_resources & ZSTAT_RES_LWPS)
		zonestat_print_res(report_fmt, "LWPS", "SYSTEM LIMIT",
		    ZONESTAT_LWPS, ZONESTAT_NAME_SYSTEM_LIMIT, usage,
		    ZS_RESOURCE_LWPS, ZS_LIMIT_LWPS);
	if (g_resources & ZSTAT_RES_LOFI)
		zonestat_print_res(report_fmt, "LOFI", "SYSTEM LIMIT",
		    ZONESTAT_LOFI, ZONESTAT_NAME_SYSTEM_LIMIT,
		    usage, ZS_RESOURCE_LOFI, ZS_LIMIT_LOFI);

	if (g_resources & ZSTAT_RES_SHM_MEMORY)
		zonestat_print_res(report_fmt, "SHM_MEMORY", "SYSTEM LIMIT",
		    ZONESTAT_SHM_MEMORY, ZONESTAT_NAME_SYSTEM_LIMIT,
		    usage, ZS_RESOURCE_SHM_MEMORY, ZS_LIMIT_SHM_MEMORY);

	if (g_resources & ZSTAT_RES_SHM_IDS)
		zonestat_print_res(report_fmt, "SHM_IDS", "SYSTEM LIMIT",
		    ZONESTAT_SHM_IDS, ZONESTAT_NAME_SYSTEM_LIMIT,
		    usage, ZS_RESOURCE_SHM_IDS, ZS_LIMIT_SHM_IDS);

	if (g_resources & ZSTAT_RES_SEM_IDS)
		zonestat_print_res(report_fmt, "SEM_IDS", "SYSTEM LIMIT",
		    ZONESTAT_SEM_IDS, ZONESTAT_NAME_SYSTEM_LIMIT,
		    usage, ZS_RESOURCE_SEM_IDS, ZS_LIMIT_SEM_IDS);

	if (g_resources & ZSTAT_RES_MSG_IDS)
		zonestat_print_res(report_fmt, "MSG_IDS", "SYSTEM LIMIT",
		    ZONESTAT_MSG_IDS, ZONESTAT_NAME_SYSTEM_LIMIT,
		    usage, ZS_RESOURCE_MSG_IDS, ZS_LIMIT_MSG_IDS);
}

/*
 * Adds comma seperated list of names to array of names
 * Returns new total number of names.
 */
static size_t
zonestat_parse_names(char *names, char ***namelist, size_t count)
{
	size_t num, i;
	char *next, *string;

	string = strdup(names);
	if (string == NULL)
		exit(zonestat_error(gettext("Out of Memory")));

	/* count names, delimiting with '\0'. */
	next = string;
	num = 1;
	while ((next = strchr(next, ',')) != NULL) {
		*next++ = '\0';
		num++;
	}

	/* Resise names array */
	*namelist = realloc(*namelist, sizeof (char *) * (num + count));
	if (*namelist == NULL)
		exit(zonestat_error(gettext("Out of Memory")));

	/* add names to names array */
	next = string;
	for (i = 0; i < num; i++) {
		(*namelist)[count + i] = next;
		next += strlen(next) + 1;
	}
	return (count + num);
}

static int
zonestat_extract_int(char *start, char *end, char **tail)
{
	int val;
	int save;

	save = *end;
	*end = '\0';
	errno = 0;
	val = strtol(start, tail, 0);
	*end = save;
	if (errno != 0 || *tail == start)
		return (-1);

	return (val);
}

/*
 * parses and [nh][nm][hs] notation into seconds
 */
static int
zonestat_parse_time(char *string, boolean_t *formatted)
{
	int seconds = 0;
	int minutes = 0;
	int hours = 0;
	char *this, *next, *end;

	*formatted = B_FALSE;

	/* Look for special tokens */
	if (strcmp("default", string) == 0)
		return (ZSTAT_INTERVAL_DEFAULT);

	if (strcmp("inf", string) == 0)
		return (ZSTAT_DURATION_INF);

	/* Look for hours */
	this = string;
	next = strchr(this, 'h');
	if (next != NULL) {
		if ((hours = zonestat_extract_int(this, next, &end)) == -1)
			return (-1);

		*formatted = B_TRUE;
		this = next + 1;
		end++;
	}

	/* Look for minutes delimiter */
	next = strrchr(this, 'm');
	if (next != NULL) {
		if ((minutes = zonestat_extract_int(this, next, &end)) == -1)
			return (-1);

		*formatted = B_TRUE;
		this = next + 1;
		end++;
	}

	/* Look for seconds delimiter */
	next = strrchr(this, 's');
	if (next != NULL) {
		if ((seconds = zonestat_extract_int(this, next, &end)) == -1)
			return (-1);

		*formatted = B_TRUE;
		this = next + 1;
		end++;
	}

	/* No delimiter found.  Treat as seconds */
	if (*formatted == B_FALSE) {
		errno = 0;
		seconds = strtol(this, &end, 0);
		if (errno != 0 || end == this)
			return (-1);
	}

	if (*end != '\0')
		return (-1);

	seconds += (minutes * 60);
	seconds += (hours * 60 * 60);

	return (seconds);
}

static void
zonestat_print_reports(zs_usage_set_t *set)
{
	zs_usage_t *usage_print;

	if (opt_report_total == B_TRUE) {
		usage_print = zs_usage_set_compute(set,
		    ZS_COMPUTE_SET_TOTAL);
		zonestat_print_header(ZSTAT_REPORT_FMT_TOTAL);
		zonestat_print_resources(ZSTAT_REPORT_FMT_TOTAL, usage_print);
		zonestat_print_footer(ZSTAT_REPORT_FMT_TOTAL);
		(void) fflush(stdout);
	}
	if (opt_report_average == B_TRUE) {
		usage_print = zs_usage_set_compute(set,
		    ZS_COMPUTE_SET_AVERAGE);
		zonestat_print_header(ZSTAT_REPORT_FMT_AVERAGE);
		zonestat_print_resources(ZSTAT_REPORT_FMT_AVERAGE, usage_print);
		zonestat_print_footer(ZSTAT_REPORT_FMT_AVERAGE);
		(void) fflush(stdout);
	}
	if (opt_report_high == B_TRUE) {
		usage_print = zs_usage_set_compute(set,
		    ZS_COMPUTE_SET_HIGH);
		zonestat_print_header(ZSTAT_REPORT_FMT_HIGH);
		zonestat_print_resources(ZSTAT_REPORT_FMT_HIGH, usage_print);
		zonestat_print_footer(ZSTAT_REPORT_FMT_HIGH);
		(void) fflush(stdout);
	}
}

static void
zonestat_set_fx()
{
	pcinfo_t pcinfo;
	pcparms_t pcparms;

	(void) strlcpy(pcinfo.pc_clname, "FX", sizeof (pcinfo.pc_clname));
	if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) {
		return;
	}
	pcparms.pc_cid = pcinfo.pc_cid;
	((fxparms_t *)pcparms.pc_clparms)->fx_upri = 60;
	((fxparms_t *)pcparms.pc_clparms)->fx_uprilim = 60;
	((fxparms_t *)pcparms.pc_clparms)->fx_tqsecs = 0;
	((fxparms_t *)pcparms.pc_clparms)->fx_tqnsecs = FX_NOCHANGE;
	(void) priocntl(P_PID, getpid(), PC_SETPARMS, (caddr_t)&pcparms);
}

static time_t
zonestat_time()
{
	time_t t;

	t = time(NULL);
	if (t < 0 && g_quit == B_FALSE)
		exit(zonestat_error(gettext(
		    "Unable to fetch current time")));

	return (t);
}

int
main(int argc, char *argv[])
{
	int arg;
	time_t now, next, start, next_report;
	zs_usage_t *usage, *usage_last = NULL, *usage_print;
	zs_usage_set_t *set;
	boolean_t formatted;
	scf_simple_prop_t *prop;
	uint64_t *intervalp;
	char *not_responding;

	/* Process command line options and args */
	while ((arg = getopt(argc, argv, "z:r:n:T:R:qpP:S:D?"))
	    != EOF) {
		switch (arg) {
		case 'z':
			opt_zonenames = B_TRUE;
			arg_zonename_count = zonestat_parse_names(optarg,
			    &arg_zonenames, arg_zonename_count);
			break;
		case 'r':
			arg_restype_count = zonestat_parse_names(optarg,
			    &arg_restypes, arg_restype_count);
			opt_restypes = B_TRUE;
			break;
		case 'n':
			opt_resnames = B_TRUE;
			arg_resname_count = zonestat_parse_names(optarg,
			    &arg_resnames, arg_resname_count);
			break;
		case 'R':
			opt_report = B_TRUE;
			arg_report_count = zonestat_parse_names(optarg,
			    &arg_reports, arg_report_count);
			break;
		case 'S':
			opt_sort = B_TRUE;
			arg_sort_count = zonestat_parse_names(optarg,
			    &arg_sort_list, arg_sort_count);
			break;
		case 'T':
			opt_timestamp = B_TRUE;
			if (strcmp(optarg, "u") == 0) {
				arg_timestamp = ZSTAT_UNIX_TIMESTAMP;
			} else if (strcmp(optarg, "d") == 0) {
				arg_timestamp = ZSTAT_DATE_TIMESTAMP;
			} else if (strcmp(optarg, "i") == 0) {
				arg_timestamp = ZSTAT_ISO_TIMESTAMP;
			} else {
				(void) zonestat_error(gettext(
				    "Invalid -T arg \"%s\". "
				    "Must be 'u', 'i', or 'd'."), optarg);
				return (zonestat_usage(B_FALSE));
			}
			break;
		case 'q':
			opt_quiet_intervals = B_TRUE;
			break;
		case 'p':
			opt_parseable = B_TRUE;
			break;
		case 'P':
			opt_line_any = B_TRUE;
			arg_line_count = zonestat_parse_names(optarg,
			    &arg_line_list, arg_line_count);
			break;
		case 'D':
			opt_debug = B_TRUE;
			break;
		case '?':
			return (zonestat_usage(B_TRUE));
		default:
			return (zonestat_usage(B_FALSE));
		}
	}

	if (opt_line_any && (!opt_parseable)) {
		(void) zonestat_error(gettext("-P requires -p"));
		return (zonestat_usage(B_FALSE));
	}

	if (opt_timestamp && arg_timestamp == ZSTAT_DATE_TIMESTAMP &&
	    opt_parseable) {
		(void) zonestat_error(gettext(
		    "-T d invalid with -p.  Use -T [u | i]"));
		return (zonestat_usage(B_FALSE));

	}
	/* Default to ISO timetamp in parseable output */
	if (!opt_timestamp && opt_parseable)
		arg_timestamp = ZSTAT_ISO_TIMESTAMP;

	/* Get the interval and count */
	optind++;
	if (argc >= optind) {
		if ((arg_interval = zonestat_parse_time(argv[optind - 1],
		    &formatted)) < 0 || arg_interval == 0)  {
			(void) zonestat_error(gettext(
			    "Invalid interval: \"%s\""), argv[optind - 1]);
			return (zonestat_usage(B_FALSE));
		}
	} else {
		(void) zonestat_error(gettext("Interval required."));
		return (zonestat_usage(B_FALSE));
	}

	if (arg_interval == ZSTAT_INTERVAL_DEFAULT) {
		/* Get the configured sample interval */
		prop = scf_simple_prop_get(NULL,
		    "svc:/system/zones-monitoring:default", "config",
		    "sample_interval");

		if (prop == NULL) {
			return (zonestat_error(gettext(
			    "Unable to fetch SMF property "
			    "\"config/sample_interval\"")));
	}
		if (scf_simple_prop_type(prop) != SCF_TYPE_COUNT) {
			return (zonestat_error(gettext("Malformed SMF property "
			    "\"config/sample_interval\".  Must be of type "
			    "\"count\"")));
	}
		intervalp = scf_simple_prop_next_count(prop);
		arg_interval = *intervalp;
		if (arg_interval == 0)
			return (zonestat_error(gettext("Malformed SMF property "
			    "\"config/sample_interval\".  Must be greater than"
			    "zero")));

		scf_simple_prop_free(prop);
	}
	optind++;
	if (argc >= optind) {
		if ((arg_duration = zonestat_parse_time(argv[optind - 1],
		    &formatted)) < 0 || arg_duration == 0)  {
			(void) zonestat_error(gettext(
			    "Invalid duration: \"%s\""), argv[optind - 1]);
			return (zonestat_usage(B_FALSE));
		}
		/* If not formatted [nh][nm][ns], treat as count */
		if (arg_duration != ZSTAT_DURATION_INF &&
		    formatted == B_FALSE)
			arg_duration *= arg_interval;
	} else {
		arg_duration = ZSTAT_DURATION_INF;
	}
	optind++;
	if (argc >= optind) {
		if ((arg_report = zonestat_parse_time(argv[optind - 1],
		    &formatted)) < 0 || arg_report == 0)  {
			(void) zonestat_error(gettext(
			    "Invalid report period: \"%s\""), argv[optind - 1]);
			return (zonestat_usage(B_FALSE));
		}
		/* If not formatted as [nh][nm][ns] treat as count */
		if (formatted == B_FALSE)
			arg_report *= arg_interval;
	} else {
		arg_report = ZSTAT_REPORT_END;
	}

	if (opt_quiet_intervals && (!opt_report)) {
		(void) zonestat_error(gettext("-q requires -R"));
		return (zonestat_usage(B_FALSE));
	}

	/* Figure out what resources to report on */
	zonestat_determine_resources();
	zonestat_determine_reports();
	zonestat_determine_lines();
	zonestat_determine_sort();

	/* Done parsing args beyond this point */

	(void) signal(SIGINT, zonestat_quithandler);
	(void) signal(SIGTERM, zonestat_quithandler);
	(void) signal(SIGHUP, zonestat_quithandler);

	/* Run at high priority to keep up with busy system */
	zonestat_set_fx();

	not_responding = gettext(
	    "Zones monitoring service \"svc:/system/zones-monitoring:default\" "
	    "not enabled or responding.");

	/* Open zone statistics */
	g_zsctl = zs_open();
	if (g_zsctl == NULL) {
		if (errno == EPERM)
			return (zonestat_error(gettext("Permission denied")));
		if (errno == EINTR || errno == ESRCH) {
			(void) zonestat_error(not_responding);
			return (3);
		}
		if (errno == ENOTSUP)
			return (zonestat_error(gettext(
			    "Mismatched zonestat version. "
			    "Re-install system/zones package.")));

		return (zonestat_error(gettext(
		    "Unexpected error.  Unable to open zone statistics.")));
	}
	usage_last = zs_usage_read(g_zsctl);
	if (usage_last == NULL) {
		if (errno == EINTR && g_quit == B_TRUE)
			return (0);
		(void) zonestat_error(not_responding);
		return (3);
	}
	set = zs_usage_set_alloc(g_zsctl);

	g_start_time = g_now_time = start = now = zonestat_time();
	g_interval = arg_interval;
	g_report_count = g_count = g_seconds = 0;

	if (opt_quiet_intervals == B_FALSE && opt_parseable == B_FALSE)
		(void) printf(gettext(
		    "Collecting data for first interval...\n"));

	for (;;) {
		time_t tosleep;

		g_now_time = now = zonestat_time();

		if (arg_report != ZSTAT_REPORT_END)
			next_report = start + ((g_report_count + 1) *
			    arg_report);

		/*
		 * Sleep till next interval.
		 */
		g_count++;
		next = g_start_time + (g_count) * g_interval;
		/*
		 * Skip to next interval if due to busy system, zonestat did
		 * not complete in time.
		 */
		while (now >= g_start_time + ((g_count + 1) * g_interval))
			g_count++;

		while (now < next) {
			/* Sleep until at next interval */
			tosleep = next - now;
			(void) sleep(tosleep);
			now = zonestat_time();
			if (g_quit == B_TRUE)
				goto interval_loop_done;
		}

		g_seconds = now - start;
		g_now_time = now;
		if ((usage = zs_usage_read(g_zsctl)) == NULL) {
			if (errno == EINTR && g_quit == B_TRUE)
				break;
			(void) zonestat_error(not_responding);
			return (3);
		}

		/* Compute cpu used since last interval */
		usage_print = zs_usage_compute(NULL, usage_last,
		    usage, ZS_COMPUTE_USAGE_INTERVAL);
		if (usage_print == NULL)
			(void) zonestat_error(gettext("Out of Memory"));


		if (opt_quiet_intervals == B_TRUE)
			goto interval_print_end;

		zonestat_print_header(ZSTAT_REPORT_FMT_INTERVAL);
		zonestat_print_resources(ZSTAT_REPORT_FMT_INTERVAL,
		    usage_print);
		zonestat_print_footer(ZSTAT_REPORT_FMT_INTERVAL);
		(void) fflush(stdout);

interval_print_end:
		(void) zs_usage_set_add(set, usage_print);


		/* Print reports if they are due */
		if (opt_report && arg_report != ZSTAT_REPORT_END &&
		    now >= next_report) {
			g_end_time  = now;
			zonestat_print_reports(set);
			zs_usage_set_free(set);
			set = zs_usage_set_alloc();
			g_start_time = now;
			g_report_count++;
		}
		zs_usage_free(usage_last);
		usage_last = usage;
		if (arg_duration != ZSTAT_DURATION_INF &&
		    g_seconds >= arg_duration)
			break;
	}
interval_loop_done:

	/* Print last reports if due */
	g_end_time = g_now_time;
	if (opt_report && zs_usage_set_count(set) > 0 &&
	    (arg_report == ZSTAT_REPORT_END || now < next_report))
		zonestat_print_reports(set);

	zs_usage_set_free(set);
	if (usage_last != NULL)
		zs_usage_free(usage_last);

	if (g_zsctl != NULL)
		zs_close(g_zsctl);

	return (0);
}