xref: /titanic_50/usr/src/cmd/rpcsvc/rstat_proc.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * rstat service:  built with rstat.x
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <signal.h>
#include <utmpx.h>
#include <nlist.h>
#include <fcntl.h>
#include <syslog.h>
#include <kstat.h>

#include <rpc/rpc.h>

#include <sys/socket.h>
#include <sys/cpuvar.h>
#include <sys/sysinfo.h>
#include <sys/systm.h>
#include <errno.h>
#include <sys/stropts.h>
#include <sys/tihdr.h>
#include <sys/sysmacros.h>

#include <net/if.h>
#include <inet/mib2.h>

#include "rstat.h"
#include "rstat_v2.h"

typedef struct {
	kstat_t	sys;
	kstat_t	vm;
} _cpu_stats_t;

/*
 *	system and cpu stats
 */
static	kstat_ctl_t	*kc;		/* libkstat cookie */
static	int	ncpus;
static	_cpu_stats_t	*cpu_stats_list = NULL;
static	kstat_t	*system_misc_ksp;
static	kstat_named_t *boot_time_knp;
static	kstat_named_t *avenrun_1min_knp, *avenrun_5min_knp, *avenrun_15min_knp;
static	int	hz;
static	struct	timeval btm;		/* boottime */

/*
 *	network interface stats
 */

typedef struct mib_item_s {
	struct mib_item_s	*next_item;
	long			group;
	long			mib_id;
	long			length;
	char			*valp;
} mib_item_t;

mib_item_t	*netstat_item;

/*
 * disk stats
 */

struct diskinfo {
	struct diskinfo *next;
	kstat_t *ks;
	kstat_io_t kios;
};

#define	NULLDISK (struct diskinfo *)0
static	struct diskinfo zerodisk = { NULL, NULL };
static	struct diskinfo *firstdisk = NULLDISK;
static	struct diskinfo *lastdisk = NULLDISK;
static	struct diskinfo *snip = NULLDISK;
static	int ndisks;

/*
 * net stats
 */

struct netinfo {
	struct netinfo *next;
	kstat_t	*ks;
	kstat_named_t *ipackets;
	kstat_named_t *opackets;
	kstat_named_t *ierrors;
	kstat_named_t *oerrors;
	kstat_named_t *collisions;
};

#define	NULLNET (struct netinfo *)0
static	struct netinfo zeronet = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
static	struct netinfo *firstnet = NULLNET;
static	struct netinfo *lastnet = NULLNET;
static	struct netinfo *netsnip = NULLNET;
static	int nnets;

/*
 *  Define EXIT_WHEN_IDLE if you are able to have this program invoked
 *  automatically on demand (as from inetd).  When defined, the service
 *  will terminated after being idle for 120 seconds.
 */

#define	EXIT_WHEN_IDLE	1

int sincelastreq = 0;		/* number of alarms since last request */
#ifdef EXIT_WHEN_IDLE
#define	CLOSEDOWN 120		/* how long to wait before exiting */
#endif /* def EXIT_WHEN_IDLE */

statstime stats_s3;
statsvar stats_s4;
/* V2 support for backwards compatibility to pre-5.0 systems */
statsswtch stats_s2;

static stat_is_init = 0;

static	void	fail(int, char *, ...);
static	void	safe_zalloc(void **, int, int);
static	kid_t	safe_kstat_read(kstat_ctl_t *, kstat_t *, void *);
static	kstat_t	*safe_kstat_lookup(kstat_ctl_t *, char *, int, char *);
static	void	*safe_kstat_data_lookup(kstat_t *, char *);
static	void	system_stat_init(void);
static	int	system_stat_load(void);
static	void	init_disks(void);
static	int	diskinfo_load(void);
static	void	init_net(void);
static	int	netinfo_load(void);

static	void	updatestat(int);

static	mib_item_t	*mibget(int sd);
static	int	mibopen(void);
static  char	*octetstr(char *buf, Octet_t *op, int code);

static	void	kstat_copy(kstat_t *, kstat_t *, int);

static	char	*cmdname = "rpc.rstatd";

#define	CPU_STAT(ksp, name)	(((kstat_named_t *)safe_kstat_data_lookup( \
				    (ksp), (name)))->value.ui64)
static	_cpu_stats_t	cpu_stats_all = { 0 };

static void
stat_init(void)
{
	struct utmpx *utmpx, utmpx_id;

	stat_is_init = 1;

	if ((kc = kstat_open()) == NULL)
		fail(1, "kstat_open(): can't open /dev/kstat");

	/*
	 * Preallocate minimal set of drive entries.
	 */

	if (stats_s4.dk_xfer.dk_xfer_val == NULL) {
		stats_s4.dk_xfer.dk_xfer_len = RSTAT_DK_NDRIVE;
		stats_s4.dk_xfer.dk_xfer_val =
		    (int *)calloc(RSTAT_DK_NDRIVE, sizeof (int));
	}

	system_stat_init();
	init_disks();
	init_net();

	/*
	 * To get the boot time, use utmpx, which is per-zone, but fall back
	 * to the system-wide kstat if utmpx is hosed for any reason.
	 */
	utmpx_id.ut_type = BOOT_TIME;
	if ((utmpx = getutxid(&utmpx_id)) != NULL)
		btm = utmpx->ut_tv;
	else {
		btm.tv_sec = boot_time_knp->value.ul;
		btm.tv_usec = 0; /* don't bother with usecs for boot time */
	}
	endutxent();
	stats_s4.boottime.tv_sec =
		stats_s2.boottime.tv_sec =
		stats_s3.boottime.tv_sec = btm.tv_sec;
	stats_s4.boottime.tv_usec =
		stats_s2.boottime.tv_usec =
		stats_s3.boottime.tv_usec = btm.tv_usec;

	updatestat(0);
	alarm(1);
	signal(SIGALRM, updatestat);
	sleep(2);		/* allow for one wake-up */
}

statsvar *
rstatproc_stats_4_svc(argp, svcrq)
void *argp;
struct svc_req *svcrq;
{
	if (! stat_is_init)
		stat_init();
#ifdef EXIT_WHEN_IDLE
	sincelastreq = 0;
#endif
	return (&stats_s4);
}

statstime *
rstatproc_stats_3_svc(argp, svcrq)
void *argp;
struct svc_req *svcrq;
{
	if (! stat_is_init)
		stat_init();
#ifdef EXIT_WHEN_IDLE
	sincelastreq = 0;
#endif
	return (&stats_s3);
}

statsswtch *
rstatproc_stats_2_svc(argp, svcrq)
void *argp;
struct svc_req *svcrq;
{
	if (! stat_is_init)
		stat_init();
#ifdef EXIT_WHEN_IDLE
	sincelastreq = 0;
#endif
	return (&stats_s2);
}


uint_t *
rstatproc_havedisk_4_svc(argp, svcrq)
void *argp;
struct svc_req *svcrq;
{
	return (rstatproc_havedisk_3_svc(argp, svcrq));
}

uint_t *
rstatproc_havedisk_3_svc(argp, svcrq)
void *argp;
struct svc_req *svcrq;
{
	static uint_t have;

	if (! stat_is_init)
		stat_init();
#ifdef EXIT_WHEN_IDLE
	sincelastreq = 0;
#endif
	have = (ndisks != 0);
	return (&have);
}

uint_t *
rstatproc_havedisk_2_svc(argp, svcrq)
void *argp;
struct svc_req *svcrq;
{
	return (rstatproc_havedisk_3_svc(argp, svcrq));
}

void
updatestat(int ignored)
{
extern int _rpcpmstart;		 /* Started by a port monitor ? */
extern int _rpcsvcdirty;	 /* Still serving ? */

#ifdef DEBUG
	fprintf(stderr, "entering updatestat\n");
#endif
#ifdef EXIT_WHEN_IDLE
	if (_rpcpmstart && sincelastreq >= CLOSEDOWN && !_rpcsvcdirty) {
#ifdef DEBUG
		fprintf(stderr, "about to closedown\n");
#endif
		exit(0);
	}
	sincelastreq++;
#endif /* def EXIT_WHEN_IDLE */

	(void) alarm(0);
#ifdef DEBUG
	fprintf(stderr, "boottime: %d %d\n", stats_s3.boottime.tv_sec,
		stats_s3.boottime.tv_usec);
#endif
	while (system_stat_load() || diskinfo_load() || netinfo_load()) {
		(void) kstat_chain_update(kc);
		system_stat_init();
		init_disks();
		init_net();
	}
	stats_s4.cp_time.cp_time_len = CPU_STATES;
	if (stats_s4.cp_time.cp_time_val == NULL)
		stats_s4.cp_time.cp_time_val =
		malloc(stats_s4.cp_time.cp_time_len * sizeof (int));
	stats_s2.cp_time[RSTAT_CPU_USER] =
	stats_s3.cp_time[RSTAT_CPU_USER] =
	stats_s4.cp_time.cp_time_val[RSTAT_CPU_USER] =
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_user");
	stats_s2.cp_time[RSTAT_CPU_NICE] =
	stats_s3.cp_time[RSTAT_CPU_NICE] =
	stats_s4.cp_time.cp_time_val[RSTAT_CPU_NICE] =
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_wait");
	stats_s2.cp_time[RSTAT_CPU_SYS] =
	stats_s3.cp_time[RSTAT_CPU_SYS] =
	stats_s4.cp_time.cp_time_val[RSTAT_CPU_SYS] =
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_kernel");
	stats_s2.cp_time[RSTAT_CPU_IDLE] =
	stats_s3.cp_time[RSTAT_CPU_IDLE] =
	stats_s4.cp_time.cp_time_val[RSTAT_CPU_IDLE] =
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_idle");

#ifdef DEBUG
	fprintf(stderr, "cpu: %d %d %d %d\n",
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_user"),
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_wait"),
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_kernel"),
		CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_idle"));
	fprintf(stderr, "cp_time: %d %d %d %d\n",
		stats_s3.cp_time[RSTAT_CPU_USER],
		stats_s3.cp_time[RSTAT_CPU_NICE],
		stats_s3.cp_time[RSTAT_CPU_SYS],
		stats_s3.cp_time[RSTAT_CPU_IDLE]);
#endif

	/* current time */
	gettimeofday((struct timeval *)&stats_s3.curtime, NULL);
	stats_s4.curtime = stats_s3.curtime;

	stats_s2.v_pgpgin =
	stats_s3.v_pgpgin =
	stats_s4.v_pgpgin = CPU_STAT(&cpu_stats_all.vm, "pgpgin");
	stats_s2.v_pgpgout =
	stats_s3.v_pgpgout =
	stats_s4.v_pgpgout = CPU_STAT(&cpu_stats_all.vm, "pgpgout");
	stats_s2.v_pswpin =
	stats_s3.v_pswpin =
	stats_s4.v_pswpin = CPU_STAT(&cpu_stats_all.vm, "pgswapin");
	stats_s2.v_pswpout =
	stats_s3.v_pswpout =
	stats_s4.v_pswpout = CPU_STAT(&cpu_stats_all.vm, "pgswapout");
	stats_s3.v_intr = CPU_STAT(&cpu_stats_all.sys, "intr");
	stats_s3.v_intr -= hz*(stats_s3.curtime.tv_sec - btm.tv_sec) +
		hz*(stats_s3.curtime.tv_usec - btm.tv_usec)/1000000;
	stats_s2.v_intr =
	stats_s4.v_intr = stats_s3.v_intr;
	/* swtch not in V1 */
	stats_s2.v_swtch =
	stats_s3.v_swtch =
	stats_s4.v_swtch = CPU_STAT(&cpu_stats_all.sys, "pswitch");

#ifdef DEBUG
	fprintf(stderr,
		"pgin: %d pgout: %d swpin: %d swpout: %d intr: %d swtch: %d\n",
		stats_s3.v_pgpgin,
		stats_s3.v_pgpgout,
		stats_s3.v_pswpin,
		stats_s3.v_pswpout,
		stats_s3.v_intr,
		stats_s3.v_swtch);
#endif
	/*
	 * V2 and V3 of rstat are limited to RSTAT_DK_NDRIVE drives
	 */
	memcpy(stats_s3.dk_xfer, stats_s4.dk_xfer.dk_xfer_val,
		RSTAT_DK_NDRIVE * sizeof (int));
	memcpy(stats_s2.dk_xfer, stats_s4.dk_xfer.dk_xfer_val,
		RSTAT_DK_NDRIVE * sizeof (int));
#ifdef DEBUG
	fprintf(stderr, "dk_xfer: %d %d %d %d\n",
		stats_s4.dk_xfer.dk_xfer_val[0],
		stats_s4.dk_xfer.dk_xfer_val[1],
		stats_s4.dk_xfer.dk_xfer_val[2],
		stats_s4.dk_xfer.dk_xfer_val[3]);
#endif

	stats_s2.if_ipackets =
	stats_s3.if_ipackets = stats_s4.if_ipackets;
	/* no s2 opackets */
	stats_s3.if_opackets = stats_s4.if_opackets;
	stats_s2.if_ierrors =
	stats_s3.if_ierrors = stats_s4.if_ierrors;
	stats_s2.if_oerrors =
	stats_s3.if_oerrors = stats_s4.if_oerrors;
	stats_s2.if_collisions =
	stats_s3.if_collisions = stats_s4.if_collisions;

	stats_s2.avenrun[0] =
	stats_s3.avenrun[0] =
	stats_s4.avenrun[0] = avenrun_1min_knp->value.ul;
	stats_s2.avenrun[1] =
	stats_s3.avenrun[1] =
	stats_s4.avenrun[1] = avenrun_5min_knp->value.ul;
	stats_s2.avenrun[2] =
	stats_s3.avenrun[2] =
	stats_s4.avenrun[2] = avenrun_15min_knp->value.ul;
#ifdef DEBUG
	fprintf(stderr, "avenrun: %d %d %d\n", stats_s3.avenrun[0],
		stats_s3.avenrun[1], stats_s3.avenrun[2]);
#endif
	signal(SIGALRM, updatestat);
	alarm(1);
}

/* --------------------------------- MIBGET -------------------------------- */

static mib_item_t *
mibget(int sd)
{
	int			flags;
	int			j, getcode;
	struct strbuf		ctlbuf, databuf;
	char			buf[512];
	struct T_optmgmt_req	*tor = (struct T_optmgmt_req *)buf;
	struct T_optmgmt_ack	*toa = (struct T_optmgmt_ack *)buf;
	struct T_error_ack	*tea = (struct T_error_ack *)buf;
	struct opthdr		*req;
	mib_item_t		*first_item = NULL;
	mib_item_t		*last_item  = NULL;
	mib_item_t		*temp;

	tor->PRIM_type = T_SVR4_OPTMGMT_REQ;
	tor->OPT_offset = sizeof (struct T_optmgmt_req);
	tor->OPT_length = sizeof (struct opthdr);
	tor->MGMT_flags = T_CURRENT;
	req = (struct opthdr *)&tor[1];
	req->level = MIB2_IP;		/* any MIB2_xxx value ok here */
	req->name  = 0;
	req->len   = 0;

	ctlbuf.buf = buf;
	ctlbuf.len = tor->OPT_length + tor->OPT_offset;
	flags = 0;
	if (putmsg(sd, &ctlbuf, NULL, flags) == -1) {
		perror("mibget: putmsg(ctl) failed");
		goto error_exit;
	}
	/*
	 * each reply consists of a ctl part for one fixed structure
	 * or table, as defined in mib2.h.  The format is a T_OPTMGMT_ACK,
	 * containing an opthdr structure.  level/name identify the entry,
	 * len is the size of the data part of the message.
	 */
	req = (struct opthdr *)&toa[1];
	ctlbuf.maxlen = sizeof (buf);
	/*CSTYLED*/
	for (j = 1; ; j++) {
		flags = 0;
		getcode = getmsg(sd, &ctlbuf, NULL, &flags);
		if (getcode == -1) {
#ifdef DEBUG_MIB
			perror("mibget getmsg(ctl) failed");
			fprintf(stderr, "#   level   name    len\n");
			i = 0;
			for (last_item = first_item; last_item;
				last_item = last_item->next_item)
				fprintf(stderr, "%d  %4d   %5d   %d\n", ++i,
					last_item->group,
					last_item->mib_id,
					last_item->length);
#endif /* DEBUG_MIB */
			goto error_exit;
		}
		if (getcode == 0 &&
			(ctlbuf.len >= sizeof (struct T_optmgmt_ack)) &&
			(toa->PRIM_type == T_OPTMGMT_ACK) &&
			(toa->MGMT_flags == T_SUCCESS) &&
			req->len == 0) {
#ifdef DEBUG_MIB
			fprintf(stderr,
		"mibget getmsg() %d returned EOD (level %d, name %d)\n",
				j, req->level, req->name);
#endif /* DEBUG_MIB */
			return (first_item);		/* this is EOD msg */
		}

		if (ctlbuf.len >= sizeof (struct T_error_ack) &&
			(tea->PRIM_type == T_ERROR_ACK)) {
#ifdef DEBUG_MIB
			fprintf(stderr,
	"mibget %d gives T_ERROR_ACK: TLI_error = 0x%x, UNIX_error = 0x%x\n",
				j, getcode, tea->TLI_error, tea->UNIX_error);
#endif /* DEBUG_MIB */
			errno = (tea->TLI_error == TSYSERR)
				? tea->UNIX_error : EPROTO;
			goto error_exit;
		}

		if (getcode != MOREDATA ||
			(ctlbuf.len < sizeof (struct T_optmgmt_ack)) ||
			(toa->PRIM_type != T_OPTMGMT_ACK) ||
			(toa->MGMT_flags != T_SUCCESS)) {
#ifdef DEBUG_MIB
			fprintf(stderr,
	"mibget getmsg(ctl) %d returned %d, ctlbuf.len = %d, PRIM_type = %d\n",
				j, getcode, ctlbuf.len, toa->PRIM_type);
			if (toa->PRIM_type == T_OPTMGMT_ACK)
				fprintf(stderr,
	"T_OPTMGMT_ACK: MGMT_flags = 0x%x, req->len = %d\n",
					toa->MGMT_flags, req->len);
#endif /* DEBUG_MIB */
			errno = ENOMSG;
			goto error_exit;
		}

		temp = malloc(sizeof (mib_item_t));
		if (!temp) {
			perror("mibget malloc failed");
			goto error_exit;
		}
		if (last_item)
			last_item->next_item = temp;
		else
			first_item = temp;
		last_item = temp;
		last_item->next_item = NULL;
		last_item->group = req->level;
		last_item->mib_id = req->name;
		last_item->length = req->len;
		last_item->valp = malloc(req->len);
#ifdef DEBUG_MIB
		fprintf(stderr,
			"msg %d:  group = %4d   mib_id = %5d   length = %d\n",
			j, last_item->group, last_item->mib_id,
			last_item->length);
#endif /* DEBUG_MIB */
		databuf.maxlen = last_item->length;
		databuf.buf    = last_item->valp;
		databuf.len    = 0;
		flags = 0;
		getcode = getmsg(sd, NULL, &databuf, &flags);
		if (getcode == -1) {
			perror("mibget getmsg(data) failed");
			goto error_exit;
		} else if (getcode != 0) {
			fprintf(stderr,
"mibget getmsg(data) returned %d, databuf.maxlen = %d, databuf.len = %d\n",
				getcode, databuf.maxlen, databuf.len);
			goto error_exit;
		}
	}

error_exit:
	while (first_item) {
		last_item = first_item;
		first_item = first_item->next_item;
		if (last_item->valp) {
			free(last_item->valp);
		}
		free(last_item);
	}
	return (first_item);
}

static int
mibopen(void)
{
	int	sd;

	/* gives us ip w/ arp on top */
	sd = open("/dev/arp", O_RDWR);
	if (sd == -1) {
		perror("arp open");
		close(sd);
		return (-1);
	}
	if (ioctl(sd, I_PUSH, "tcp") == -1) {
		perror("tcp I_PUSH");
		close(sd);
		return (-1);
	}
	if (ioctl(sd, I_PUSH, "udp") == -1) {
		perror("udp I_PUSH");
		close(sd);
		return (-1);
	}
	return (sd);
}

static char *
octetstr(char *buf, Octet_t *op, int code)
{
	int	i;
	char	*cp;

	cp = buf;
	if (op)
		for (i = 0; i < op->o_length; i++)
			switch (code) {
			case 'd':
				sprintf(cp, "%d.", 0xff & op->o_bytes[i]);
				cp = strchr(cp, '\0');
				break;
			case 'a':
				*cp++ = op->o_bytes[i];
				break;
			case 'h':
			default:
				sprintf(cp, "%02x:", 0xff & op->o_bytes[i]);
				cp += 3;
				break;
			}
	if (code != 'a' && cp != buf)
		cp--;
	*cp = '\0';
	return (buf);
}

static void
fail(int do_perror, char *message, ...)
{
	va_list args;

	va_start(args, message);
	fprintf(stderr, "%s: ", cmdname);
	vfprintf(stderr, message, args);
	va_end(args);
	if (do_perror)
		fprintf(stderr, ": %s", strerror(errno));
	fprintf(stderr, "\n");
	exit(2);
}

static void
safe_zalloc(void **ptr, int size, int free_first)
{
	if (free_first && *ptr != NULL)
		free(*ptr);
	if ((*ptr = malloc(size)) == NULL)
		fail(1, "malloc failed");
	memset(*ptr, 0, size);
}

kid_t
safe_kstat_read(kstat_ctl_t *kctl, kstat_t *ksp, void *data)
{
	kid_t kstat_chain_id = kstat_read(kctl, ksp, data);

	if (kstat_chain_id == -1)
		fail(1, "kstat_read(%x, '%s') failed", kctl, ksp->ks_name);
	return (kstat_chain_id);
}

kstat_t *
safe_kstat_lookup(kstat_ctl_t *kctl, char *ks_module, int ks_instance,
	char *ks_name)
{
	kstat_t *ksp = kstat_lookup(kctl, ks_module, ks_instance, ks_name);

	if (ksp == NULL)
		fail(0, "kstat_lookup('%s', %d, '%s') failed",
			ks_module == NULL ? "" : ks_module,
			ks_instance,
			ks_name == NULL ? "" : ks_name);
	return (ksp);
}

void *
safe_kstat_data_lookup(kstat_t *ksp, char *name)
{
	void *fp = kstat_data_lookup(ksp, name);

	if (fp == NULL) {
		fail(0, "kstat_data_lookup('%s', '%s') failed",
			ksp->ks_name, name);
	}
	return (fp);
}

/*
 * Get various KIDs for subsequent system_stat_load operations.
 */

static void
system_stat_init(void)
{
	kstat_t *ksp;
	int i, nvmks;

	/*
	 * Global statistics
	 */

	system_misc_ksp	= safe_kstat_lookup(kc, "unix", 0, "system_misc");

	safe_kstat_read(kc, system_misc_ksp, NULL);
	boot_time_knp = safe_kstat_data_lookup(system_misc_ksp, "boot_time");
	avenrun_1min_knp = safe_kstat_data_lookup(system_misc_ksp,
		"avenrun_1min");
	avenrun_5min_knp = safe_kstat_data_lookup(system_misc_ksp,
		"avenrun_5min");
	avenrun_15min_knp = safe_kstat_data_lookup(system_misc_ksp,
		"avenrun_15min");

	/*
	 * Per-CPU statistics
	 */

	ncpus = 0;
	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next)
		if (strcmp(ksp->ks_module, "cpu") == 0 &&
		    strcmp(ksp->ks_name, "sys") == 0)
			ncpus++;

	safe_zalloc((void **)&cpu_stats_list, ncpus * sizeof (*cpu_stats_list),
	    1);

	ncpus = 0;
	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next)
		if (strcmp(ksp->ks_module, "cpu") == 0 &&
		    strcmp(ksp->ks_name, "sys") == 0 &&
		    kstat_read(kc, ksp, NULL) != -1) {
			kstat_copy(ksp, &cpu_stats_list[ncpus].sys,
			    1);
			if ((ksp = kstat_lookup(kc, "cpu", ksp->ks_instance,
			    "vm")) != NULL && kstat_read(kc, ksp, NULL) != -1)
				kstat_copy(ksp, &cpu_stats_list[ncpus].vm, 1);
			else
				fail(0, "couldn't find per-CPU VM statistics");
			ncpus++;
		    }

	if (ncpus == 0)
		fail(0, "couldn't find per-CPU statistics");
}

/*
 * load statistics, summing across CPUs where needed
 */

static int
system_stat_load(void)
{
	int i, j;
	_cpu_stats_t cs;
	ulong_t *np, *tp;

	/*
	 * Global statistics
	 */

	safe_kstat_read(kc, system_misc_ksp, NULL);

	/*
	 * Per-CPU statistics.
	 */

	for (i = 0; i < ncpus; i++) {
		if (kstat_read(kc, &cpu_stats_list[i].sys, NULL) == -1 ||
		    kstat_read(kc, &cpu_stats_list[i].vm, NULL) == -1)
			return (1);
		if (i == 0) {
			kstat_copy(&cpu_stats_list[0].sys, &cpu_stats_all.sys,
			    1);
			kstat_copy(&cpu_stats_list[0].vm, &cpu_stats_all.vm, 1);
		} else {
			kstat_named_t *nkp;
			kstat_named_t *tkp;

			/*
			 * Other CPUs' statistics are accumulated in
			 * cpu_stats_all, initialized at the first iteration of
			 * the loop.
			 */
			nkp = (kstat_named_t *)cpu_stats_all.sys.ks_data;
			tkp = (kstat_named_t *)cpu_stats_list[i].sys.ks_data;
			for (j = 0; j < cpu_stats_list[i].sys.ks_ndata; j++)
				(nkp++)->value.ui64 += (tkp++)->value.ui64;
			nkp = (kstat_named_t *)cpu_stats_all.vm.ks_data;
			tkp = (kstat_named_t *)cpu_stats_list[i].vm.ks_data;
			for (j = 0; j < cpu_stats_list[i].vm.ks_ndata; j++)
				(nkp++)->value.ui64 += (tkp++)->value.ui64;
		}
	}
	return (0);
}

static int
kscmp(kstat_t *ks1, kstat_t *ks2)
{
	int cmp;

	cmp = strcmp(ks1->ks_module, ks2->ks_module);
	if (cmp != 0)
		return (cmp);
	cmp = ks1->ks_instance - ks2->ks_instance;
	if (cmp != 0)
		return (cmp);
	return (strcmp(ks1->ks_name, ks2->ks_name));
}

static void
init_disks(void)
{
	struct diskinfo *disk, *prevdisk, *comp;
	kstat_t *ksp;

	ndisks = 0;
	disk = &zerodisk;

	/*
	 * Patch the snip in the diskinfo list (see below)
	 */
	if (snip)
		lastdisk->next = snip;

	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {

		if (ksp->ks_type != KSTAT_TYPE_IO ||
		    strcmp(ksp->ks_class, "disk") != 0)
			continue;
		prevdisk = disk;
		if (disk->next)
			disk = disk->next;
		else {
			safe_zalloc((void **)&disk->next,
			    sizeof (struct diskinfo), 0);
			disk = disk->next;
			disk->next = NULLDISK;
		}
		disk->ks = ksp;
		memset((void *)&disk->kios, 0, sizeof (kstat_io_t));
		disk->kios.wlastupdate = disk->ks->ks_crtime;
		disk->kios.rlastupdate = disk->ks->ks_crtime;

		/*
		 * Insertion sort on (ks_module, ks_instance, ks_name)
		 */
		comp = &zerodisk;
		while (kscmp(disk->ks, comp->next->ks) > 0)
			comp = comp->next;
		if (prevdisk != comp) {
			prevdisk->next = disk->next;
			disk->next = comp->next;
			comp->next = disk;
			disk = prevdisk;
		}
		ndisks++;
	}
	/*
	 * Put a snip in the linked list of diskinfos.  The idea:
	 * If there was a state change such that now there are fewer
	 * disks, we snip the list and retain the tail, rather than
	 * freeing it.  At the next state change, we clip the tail back on.
	 * This prevents a lot of malloc/free activity, and it's simpler.
	 */
	lastdisk = disk;
	snip = disk->next;
	disk->next = NULLDISK;

	firstdisk = zerodisk.next;

	if (ndisks > stats_s4.dk_xfer.dk_xfer_len) {
		stats_s4.dk_xfer.dk_xfer_len = ndisks;
		safe_zalloc((void **)&stats_s4.dk_xfer.dk_xfer_val,
			ndisks * sizeof (int), 1);
	}
}

static int
diskinfo_load(void)
{
	struct diskinfo *disk;
	int i;

	for (disk = firstdisk, i = 0; disk; disk = disk->next, i++) {
		if (kstat_read(kc, disk->ks, (void *)&disk->kios) == -1)
			return (1);
		stats_s4.dk_xfer.dk_xfer_val[i] = disk->kios.reads +
			disk->kios.writes;
	}
	return (0);
}

static void
init_net(void)
{
	static int sd;
	mib_item_t *item;
	mib2_ipAddrEntry_t *ap;
	char namebuf[KSTAT_STRLEN];
	struct netinfo *net, *prevnet, *comp;
	kstat_t *ksp;

	if (sd) {
		close(sd);
	}
	while (netstat_item) {
		item = netstat_item;
		netstat_item = netstat_item->next_item;
		if (item->valp) {
			free(item->valp);
		}
		free(item);
	}
	sd = mibopen();
	if (sd == -1) {
#ifdef DEBUG
		fprintf(stderr, "mibopen() failed\n");
#endif
		sd = 0;
	} else {
		if ((netstat_item = mibget(sd)) == NULL) {
#ifdef DEBUG
			fprintf(stderr, "mibget() failed\n");
#endif
			close(sd);
			sd = 0;
		}
	}
#ifdef DEBUG
	fprintf(stderr, "mibget returned item: %x\n", netstat_item);
#endif

	nnets = 0;
	net = &zeronet;

	if (netsnip)
		lastnet->next = netsnip;

	for (item = netstat_item; item; item = item->next_item) {
#ifdef DEBUG_MIB
		fprintf(stderr, "\n--- Item %x ---\n", item);
		fprintf(stderr,
		"Group = %d, mib_id = %d, length = %d, valp = 0x%x\n",
		item->group, item->mib_id, item->length,
		item->valp);
#endif
		if (item->group != MIB2_IP || item->mib_id != MIB2_IP_20)
			continue;
		ap = (mib2_ipAddrEntry_t *)item->valp;
		for (; (char *)ap < item->valp + item->length; ap++) {

			octetstr(namebuf, &ap->ipAdEntIfIndex, 'a');
#ifdef DEBUG
			fprintf(stderr, "%s ", namebuf);
#endif
			if (strlen(namebuf) == 0)
				continue;
			/*
			 * We found a device of interest.
			 * Now, let's see if there's a kstat for it.
			 */
			if ((ksp = kstat_lookup(kc, NULL, -1, namebuf)) == NULL)
				continue;
			if (ksp->ks_type != KSTAT_TYPE_NAMED)
				continue;
			if (kstat_read(kc, ksp, NULL) == -1)
				continue;
			prevnet = net;
			if (net->next)
				net = net->next;
			else {
				safe_zalloc((void **)&net->next,
					sizeof (struct netinfo), 0);
				net = net->next;
				net->next = NULLNET;
			}
			net->ks = ksp;
			net->ipackets	= kstat_data_lookup(net->ks,
				"ipackets");
			net->opackets	= kstat_data_lookup(net->ks,
				"opackets");
			net->ierrors	= kstat_data_lookup(net->ks,
				"ierrors");
			net->oerrors	= kstat_data_lookup(net->ks,
				"oerrors");
			net->collisions	= kstat_data_lookup(net->ks,
				"collisions");
			/*
			 * Insertion sort on the name
			 */
			comp = &zeronet;
			while (strcmp(net->ks->ks_name,
			    comp->next->ks->ks_name) > 0)
				comp = comp->next;
			if (prevnet != comp) {
				prevnet->next = net->next;
				net->next = comp->next;
				comp->next = net;
				net = prevnet;
			}
			nnets++;
		}
#ifdef DEBUG
		fprintf(stderr, "\n");
#endif
	}
	/*
	 * Put a snip in the linked list of netinfos.  The idea:
	 * If there was a state change such that now there are fewer
	 * nets, we snip the list and retain the tail, rather than
	 * freeing it.  At the next state change, we clip the tail back on.
	 * This prevents a lot of malloc/free activity, and it's simpler.
	 */
	lastnet = net;
	netsnip = net->next;
	net->next = NULLNET;

	firstnet = zeronet.next;
}

static int
netinfo_load(void)
{
	struct netinfo *net;

	if (netstat_item == NULL) {
#ifdef DEBUG
		fprintf(stderr, "No net stats\n");
#endif
		return (0);
	}

	stats_s4.if_ipackets =
	stats_s4.if_opackets =
	stats_s4.if_ierrors =
	stats_s4.if_oerrors =
	stats_s4.if_collisions = 0;

	for (net = firstnet; net; net = net->next) {
		if (kstat_read(kc, net->ks, NULL) == -1)
			return (1);
		if (net->ipackets)
			stats_s4.if_ipackets	+= net->ipackets->value.ul;
		if (net->opackets)
			stats_s4.if_opackets	+= net->opackets->value.ul;
		if (net->ierrors)
			stats_s4.if_ierrors	+= net->ierrors->value.ul;
		if (net->oerrors)
			stats_s4.if_oerrors	+= net->oerrors->value.ul;
		if (net->collisions)
			stats_s4.if_collisions	+= net->collisions->value.ul;
	}
#ifdef DEBUG
	fprintf(stderr,
	    "ipackets: %d opackets: %d ierrors: %d oerrors: %d colls: %d\n",
		stats_s4.if_ipackets,
		stats_s4.if_opackets,
		stats_s4.if_ierrors,
		stats_s4.if_oerrors,
		stats_s4.if_collisions);
#endif
	return (0);
}

static void
kstat_copy(kstat_t *src, kstat_t *dst, int fr)
{
	if (fr)
		free(dst->ks_data);
	*dst = *src;
	if (src->ks_data != NULL) {
		safe_zalloc(&dst->ks_data, src->ks_data_size, 0);
		(void) memcpy(dst->ks_data, src->ks_data, src->ks_data_size);
	} else {
		dst->ks_data = NULL;
		dst->ks_data_size = 0;
	}
}