xref: /freebsd/usr.bin/ctlstat/ctlstat.c (revision 1a7f22d9c211f504f6c48a86401469181a67ec34)

/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2004, 2008, 2009 Silicon Graphics International Corp.
 * Copyright (c) 2017 Alexander Motin <mav@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * $Id: //depot/users/kenm/FreeBSD-test2/usr.bin/ctlstat/ctlstat.c#4 $
 */
/*
 * CAM Target Layer statistics program
 *
 * Authors: Ken Merry <ken@FreeBSD.org>, Will Andrews <will@FreeBSD.org>
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/callout.h>
#include <sys/ioctl.h>
#include <sys/queue.h>
#include <sys/resource.h>
#include <sys/sbuf.h>
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <bsdxml.h>
#include <malloc_np.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <inttypes.h>
#include <getopt.h>
#include <string.h>
#include <errno.h>
#include <err.h>
#include <ctype.h>
#include <bitstring.h>
#include <cam/scsi/scsi_all.h>
#include <cam/ctl/ctl.h>
#include <cam/ctl/ctl_io.h>
#include <cam/ctl/ctl_scsi_all.h>
#include <cam/ctl/ctl_util.h>
#include <cam/ctl/ctl_backend.h>
#include <cam/ctl/ctl_ioctl.h>

/*
 * The default amount of space we allocate for stats storage space.
 * We dynamically allocate more if needed.
 */
#define	CTL_STAT_NUM_ITEMS	256

static int ctl_stat_bits;

static const char *ctlstat_opts = "Cc:DPdhjl:n:p:tw:";
static const char *ctlstat_usage = "Usage:  ctlstat [-CDPdjht] [-l lunnum]"
				   "[-c count] [-n numdevs] [-w wait]\n";

struct ctl_cpu_stats {
	uint64_t user;
	uint64_t nice;
	uint64_t system;
	uint64_t intr;
	uint64_t idle;
};

typedef enum {
	CTLSTAT_MODE_STANDARD,
	CTLSTAT_MODE_DUMP,
	CTLSTAT_MODE_JSON,
	CTLSTAT_MODE_PROMETHEUS,
} ctlstat_mode_types;

#define	CTLSTAT_FLAG_CPU		(1 << 0)
#define	CTLSTAT_FLAG_HEADER		(1 << 1)
#define	CTLSTAT_FLAG_FIRST_RUN		(1 << 2)
#define	CTLSTAT_FLAG_TOTALS		(1 << 3)
#define	CTLSTAT_FLAG_DMA_TIME		(1 << 4)
#define	CTLSTAT_FLAG_TIME_VALID		(1 << 5)
#define	CTLSTAT_FLAG_MASK		(1 << 6)
#define	CTLSTAT_FLAG_LUNS		(1 << 7)
#define	CTLSTAT_FLAG_PORTS		(1 << 8)
#define	F_CPU(ctx) ((ctx)->flags & CTLSTAT_FLAG_CPU)
#define	F_HDR(ctx) ((ctx)->flags & CTLSTAT_FLAG_HEADER)
#define	F_FIRST(ctx) ((ctx)->flags & CTLSTAT_FLAG_FIRST_RUN)
#define	F_TOTALS(ctx) ((ctx)->flags & CTLSTAT_FLAG_TOTALS)
#define	F_DMA(ctx) ((ctx)->flags & CTLSTAT_FLAG_DMA_TIME)
#define	F_TIMEVAL(ctx) ((ctx)->flags & CTLSTAT_FLAG_TIME_VALID)
#define	F_MASK(ctx) ((ctx)->flags & CTLSTAT_FLAG_MASK)
#define	F_LUNS(ctx) ((ctx)->flags & CTLSTAT_FLAG_LUNS)
#define	F_PORTS(ctx) ((ctx)->flags & CTLSTAT_FLAG_PORTS)

struct ctlstat_context {
	ctlstat_mode_types mode;
	int flags;
	struct ctl_io_stats *cur_stats, *prev_stats;
	struct ctl_io_stats cur_total_stats[3], prev_total_stats[3];
	struct timespec cur_time, prev_time;
	struct ctl_cpu_stats cur_cpu, prev_cpu;
	uint64_t cur_total_jiffies, prev_total_jiffies;
	uint64_t cur_idle, prev_idle;
	bitstr_t *item_mask;
	int cur_items, prev_items;
	int cur_alloc, prev_alloc;
	int numdevs;
	int header_interval;
};

struct cctl_portlist_data {
	int level;
	struct sbuf *cur_sb[32];
	int lun;
	int ntargets;
	char *target;
	char **targets;
};

#ifndef min
#define	min(x,y)	(((x) < (y)) ? (x) : (y))
#endif

static void usage(int error);
static int getstats(int fd, int *alloc_items, int *num_items,
    struct ctl_io_stats **xstats, struct timespec *cur_time, int *time_valid);
static int getcpu(struct ctl_cpu_stats *cpu_stats);
static void compute_stats(struct ctl_io_stats *cur_stats,
			  struct ctl_io_stats *prev_stats,
			  long double etime, long double *mbsec,
			  long double *kb_per_transfer,
			  long double *transfers_per_second,
			  long double *ms_per_transfer,
			  long double *ms_per_dma,
			  long double *dmas_per_second);

static void
usage(int error)
{
	fputs(ctlstat_usage, error ? stderr : stdout);
}

static int
getstats(int fd, int *alloc_items, int *num_items, struct ctl_io_stats **stats,
	 struct timespec *cur_time, int *flags)
{
	struct ctl_get_io_stats get_stats;
	int more_space_count = 0;

	if (*alloc_items == 0)
		*alloc_items = CTL_STAT_NUM_ITEMS;
retry:
	if (*stats == NULL)
		*stats = malloc(sizeof(**stats) * *alloc_items);

	memset(&get_stats, 0, sizeof(get_stats));
	get_stats.alloc_len = *alloc_items * sizeof(**stats);
	memset(*stats, 0, get_stats.alloc_len);
	get_stats.stats = *stats;

	if (ioctl(fd, (*flags & CTLSTAT_FLAG_PORTS) ? CTL_GET_PORT_STATS :
	    CTL_GET_LUN_STATS, &get_stats) == -1)
		err(1, "CTL_GET_*_STATS ioctl returned error");

	switch (get_stats.status) {
	case CTL_SS_OK:
		break;
	case CTL_SS_ERROR:
		err(1, "CTL_GET_*_STATS ioctl returned CTL_SS_ERROR");
		break;
	case CTL_SS_NEED_MORE_SPACE:
		if (more_space_count >= 2)
			errx(1, "CTL_GET_*_STATS returned NEED_MORE_SPACE again");
		*alloc_items = get_stats.num_items * 5 / 4;
		free(*stats);
		*stats = NULL;
		more_space_count++;
		goto retry;
		break; /* NOTREACHED */
	default:
		errx(1, "CTL_GET_*_STATS ioctl returned unknown status %d",
		     get_stats.status);
		break;
	}

	*num_items = get_stats.fill_len / sizeof(**stats);
	cur_time->tv_sec = get_stats.timestamp.tv_sec;
	cur_time->tv_nsec = get_stats.timestamp.tv_nsec;
	if (get_stats.flags & CTL_STATS_FLAG_TIME_VALID)
		*flags |= CTLSTAT_FLAG_TIME_VALID;
	else
		*flags &= ~CTLSTAT_FLAG_TIME_VALID;

	return (0);
}

static int
getcpu(struct ctl_cpu_stats *cpu_stats)
{
	long cp_time[CPUSTATES];
	size_t cplen;

	cplen = sizeof(cp_time);

	if (sysctlbyname("kern.cp_time", &cp_time, &cplen, NULL, 0) == -1) {
		warn("sysctlbyname(kern.cp_time...) failed");
		return (1);
	}

	cpu_stats->user = cp_time[CP_USER];
	cpu_stats->nice = cp_time[CP_NICE];
	cpu_stats->system = cp_time[CP_SYS];
	cpu_stats->intr = cp_time[CP_INTR];
	cpu_stats->idle = cp_time[CP_IDLE];

	return (0);
}

static void
compute_stats(struct ctl_io_stats *cur_stats,
	      struct ctl_io_stats *prev_stats, long double etime,
	      long double *mbsec, long double *kb_per_transfer,
	      long double *transfers_per_second, long double *ms_per_transfer,
	      long double *ms_per_dma, long double *dmas_per_second)
{
	uint64_t total_bytes = 0, total_operations = 0, total_dmas = 0;
	struct bintime total_time_bt, total_dma_bt;
	struct timespec total_time_ts, total_dma_ts;
	int i;

	bzero(&total_time_bt, sizeof(total_time_bt));
	bzero(&total_dma_bt, sizeof(total_dma_bt));
	bzero(&total_time_ts, sizeof(total_time_ts));
	bzero(&total_dma_ts, sizeof(total_dma_ts));
	for (i = 0; i < CTL_STATS_NUM_TYPES; i++) {
		total_bytes += cur_stats->bytes[i];
		total_operations += cur_stats->operations[i];
		total_dmas += cur_stats->dmas[i];
		bintime_add(&total_time_bt, &cur_stats->time[i]);
		bintime_add(&total_dma_bt, &cur_stats->dma_time[i]);
		if (prev_stats != NULL) {
			total_bytes -= prev_stats->bytes[i];
			total_operations -= prev_stats->operations[i];
			total_dmas -= prev_stats->dmas[i];
			bintime_sub(&total_time_bt, &prev_stats->time[i]);
			bintime_sub(&total_dma_bt, &prev_stats->dma_time[i]);
		}
	}

	*mbsec = total_bytes;
	*mbsec /= 1024 * 1024;
	if (etime > 0.0)
		*mbsec /= etime;
	else
		*mbsec = 0;
	*kb_per_transfer = total_bytes;
	*kb_per_transfer /= 1024;
	if (total_operations > 0)
		*kb_per_transfer /= total_operations;
	else
		*kb_per_transfer = 0;
	*transfers_per_second = total_operations;
	*dmas_per_second = total_dmas;
	if (etime > 0.0) {
		*transfers_per_second /= etime;
		*dmas_per_second /= etime;
	} else {
		*transfers_per_second = 0;
		*dmas_per_second = 0;
	}

	bintime2timespec(&total_time_bt, &total_time_ts);
	bintime2timespec(&total_dma_bt, &total_dma_ts);
	if (total_operations > 0) {
		/*
		 * Convert the timespec to milliseconds.
		 */
		*ms_per_transfer = total_time_ts.tv_sec * 1000;
		*ms_per_transfer += total_time_ts.tv_nsec / 1000000;
		*ms_per_transfer /= total_operations;
	} else
		*ms_per_transfer = 0;

	if (total_dmas > 0) {
		/*
		 * Convert the timespec to milliseconds.
		 */
		*ms_per_dma = total_dma_ts.tv_sec * 1000;
		*ms_per_dma += total_dma_ts.tv_nsec / 1000000;
		*ms_per_dma /= total_dmas;
	} else
		*ms_per_dma = 0;
}

/* The dump_stats() and json_stats() functions perform essentially the same
 * purpose, but dump the statistics in different formats.  JSON is more
 * conducive to programming, however.
 */

#define	PRINT_BINTIME(bt) \
	printf("%jd.%06ju", (intmax_t)(bt).sec, \
	       (uintmax_t)(((bt).frac >> 32) * 1000000 >> 32))
static const char *iotypes[] = {"NO IO", "READ", "WRITE"};

static void
ctlstat_dump(struct ctlstat_context *ctx)
{
	int iotype, i, n;
	struct ctl_io_stats *stats = ctx->cur_stats;

	for (i = n = 0; i < ctx->cur_items;i++) {
		if (F_MASK(ctx) && bit_test(ctx->item_mask,
		    (int)stats[i].item) == 0)
			continue;
		printf("%s %d\n", F_PORTS(ctx) ? "port" : "lun", stats[i].item);
		for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) {
			printf("  io type %d (%s)\n", iotype, iotypes[iotype]);
			printf("   bytes %ju\n", (uintmax_t)
			    stats[i].bytes[iotype]);
			printf("   operations %ju\n", (uintmax_t)
			    stats[i].operations[iotype]);
			printf("   dmas %ju\n", (uintmax_t)
			    stats[i].dmas[iotype]);
			printf("   io time ");
			PRINT_BINTIME(stats[i].time[iotype]);
			printf("\n   dma time ");
			PRINT_BINTIME(stats[i].dma_time[iotype]);
			printf("\n");
		}
		if (++n >= ctx->numdevs)
			break;
	}
}

static void
ctlstat_json(struct ctlstat_context *ctx) {
	int iotype, i, n;
	struct ctl_io_stats *stats = ctx->cur_stats;

	printf("{\"%s\":[", F_PORTS(ctx) ? "ports" : "luns");
	for (i = n = 0; i < ctx->cur_items; i++) {
		if (F_MASK(ctx) && bit_test(ctx->item_mask,
		    (int)stats[i].item) == 0)
			continue;
		printf("{\"num\":%d,\"io\":[",
		    stats[i].item);
		for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) {
			printf("{\"type\":\"%s\",", iotypes[iotype]);
			printf("\"bytes\":%ju,", (uintmax_t)
			    stats[i].bytes[iotype]);
			printf("\"operations\":%ju,", (uintmax_t)
			    stats[i].operations[iotype]);
			printf("\"dmas\":%ju,", (uintmax_t)
			    stats[i].dmas[iotype]);
			printf("\"io time\":");
			PRINT_BINTIME(stats[i].time[iotype]);
			printf(",\"dma time\":");
			PRINT_BINTIME(stats[i].dma_time[iotype]);
			printf("}");
			if (iotype < (CTL_STATS_NUM_TYPES - 1))
				printf(","); /* continue io array */
		}
		printf("]}");
		if (++n >= ctx->numdevs)
			break;
		if (i < (ctx->cur_items - 1))
			printf(","); /* continue lun array */
	}
	printf("]}");
}

#define CTLSTAT_PROMETHEUS_LOOP(field) \
	for (i = n = 0; i < ctx->cur_items; i++) { \
		if (F_MASK(ctx) && bit_test(ctx->item_mask, \
		    (int)stats[i].item) == 0) \
			continue; \
		for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) { \
			int lun = stats[i].item; \
			if (lun >= targdata.ntargets) \
			    errx(1, "LUN %u out of range", lun); \
			printf("iscsi_target_" #field "{" \
			    "lun=\"%u\",target=\"%s\",type=\"%s\"} %" PRIu64 \
			    "\n", \
			    lun, targdata.targets[lun], iotypes[iotype], \
			    stats[i].field[iotype]); \
		} \
	} \

#define CTLSTAT_PROMETHEUS_TIMELOOP(field) \
	for (i = n = 0; i < ctx->cur_items; i++) { \
		if (F_MASK(ctx) && bit_test(ctx->item_mask, \
		    (int)stats[i].item) == 0) \
			continue; \
		for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) { \
			uint64_t us; \
			struct timespec ts; \
			int lun = stats[i].item; \
			if (lun >= targdata.ntargets) \
			    errx(1, "LUN %u out of range", lun); \
			bintime2timespec(&stats[i].field[iotype], &ts); \
			us = ts.tv_sec * 1000000 + ts.tv_nsec / 1000; \
			printf("iscsi_target_" #field "{" \
			    "lun=\"%u\",target=\"%s\",type=\"%s\"} %" PRIu64 \
			    "\n", \
			    lun, targdata.targets[lun], iotypes[iotype], us); \
		} \
	} \

static void
cctl_start_pelement(void *user_data, const char *name, const char **attr __unused)
{
	struct cctl_portlist_data* targdata = user_data;

	targdata->level++;
	if ((u_int)targdata->level >= (sizeof(targdata->cur_sb) /
	    sizeof(targdata->cur_sb[0])))
		errx(1, "%s: too many nesting levels, %zd max", __func__,
		     sizeof(targdata->cur_sb) / sizeof(targdata->cur_sb[0]));

	targdata->cur_sb[targdata->level] = sbuf_new_auto();
	if (targdata->cur_sb[targdata->level] == NULL)
		err(1, "%s: Unable to allocate sbuf", __func__);

	if (strcmp(name, "targ_port") == 0) {
		targdata->lun = -1;
		free(targdata->target);
		targdata->target = NULL;
	}
}

static void
cctl_char_phandler(void *user_data, const XML_Char *str, int len)
{
	struct cctl_portlist_data *targdata = user_data;

	sbuf_bcat(targdata->cur_sb[targdata->level], str, len);
}

static void
cctl_end_pelement(void *user_data, const char *name)
{
	struct cctl_portlist_data* targdata = user_data;
	char *str;

	if (targdata->cur_sb[targdata->level] == NULL)
		errx(1, "%s: no valid sbuf at level %d (name %s)", __func__,
		     targdata->level, name);

	if (sbuf_finish(targdata->cur_sb[targdata->level]) != 0)
		err(1, "%s: sbuf_finish", __func__);
	str = strdup(sbuf_data(targdata->cur_sb[targdata->level]));
	if (str == NULL)
		err(1, "%s can't allocate %zd bytes for string", __func__,
		    sbuf_len(targdata->cur_sb[targdata->level]));

	sbuf_delete(targdata->cur_sb[targdata->level]);
	targdata->cur_sb[targdata->level] = NULL;
	targdata->level--;

	if (strcmp(name, "target") == 0) {
		free(targdata->target);
		targdata->target = str;
	} else if (strcmp(name, "lun") == 0) {
		targdata->lun = atoi(str);
		free(str);
	} else if (strcmp(name, "targ_port") == 0) {
		if (targdata->lun >= 0 && targdata->target != NULL) {
			if (targdata->lun >= targdata->ntargets) {
				/*
				 * This can happen for example if there are
				 * holes in CTL's lunlist.
				 */
				targdata->ntargets = MAX(targdata->ntargets * 2,
					targdata->lun + 1);
				size_t newsize = targdata->ntargets *
					sizeof(char*);
				targdata->targets = rallocx(targdata->targets,
					newsize, MALLOCX_ZERO);
			}
			free(targdata->targets[targdata->lun]);
			targdata->targets[targdata->lun] = targdata->target;
			targdata->target = NULL;
		}
		free(str);
	} else {
		free(str);
	}
}

static void
ctlstat_prometheus(int fd, struct ctlstat_context *ctx) {
	struct ctl_io_stats *stats = ctx->cur_stats;
	struct ctl_lun_list list;
	struct cctl_portlist_data targdata;
	XML_Parser parser;
	char *port_str = NULL;
	int iotype, i, n, retval;
	int port_len = 4096;

	bzero(&targdata, sizeof(targdata));
	targdata.ntargets = ctx->cur_items;
	targdata.targets = calloc(targdata.ntargets, sizeof(char*));
retry:
	port_str = (char *)realloc(port_str, port_len);
	bzero(&list, sizeof(list));
	list.alloc_len = port_len;
	list.status = CTL_LUN_LIST_NONE;
	list.lun_xml = port_str;
	if (ioctl(fd, CTL_PORT_LIST, &list) == -1)
		err(1, "%s: error issuing CTL_PORT_LIST ioctl", __func__);
	if (list.status == CTL_LUN_LIST_ERROR) {
		warnx("%s: error returned from CTL_PORT_LIST ioctl:\n%s",
		      __func__, list.error_str);
	} else if (list.status == CTL_LUN_LIST_NEED_MORE_SPACE) {
		port_len <<= 1;
		goto retry;
	}

	parser = XML_ParserCreate(NULL);
	if (parser == NULL)
		err(1, "%s: Unable to create XML parser", __func__);
	XML_SetUserData(parser, &targdata);
	XML_SetElementHandler(parser, cctl_start_pelement, cctl_end_pelement);
	XML_SetCharacterDataHandler(parser, cctl_char_phandler);

	retval = XML_Parse(parser, port_str, strlen(port_str), 1);
	if (retval != 1) {
		errx(1, "%s: Unable to parse XML: Error %d", __func__,
		    XML_GetErrorCode(parser));
	}
	XML_ParserFree(parser);

	/*
	 * NB: Some clients will print a warning if we don't set Content-Length,
	 * but they still work.  And the data still gets into Prometheus.
	 */
	printf("HTTP/1.1 200 OK\r\n"
	       "Connection: close\r\n"
	       "Content-Type: text/plain; version=0.0.4\r\n"
	       "\r\n");

	printf("# HELP iscsi_target_bytes Number of bytes\n"
	       "# TYPE iscsi_target_bytes counter\n");
	CTLSTAT_PROMETHEUS_LOOP(bytes);
	printf("# HELP iscsi_target_dmas Number of DMA\n"
	       "# TYPE iscsi_target_dmas counter\n");
	CTLSTAT_PROMETHEUS_LOOP(dmas);
	printf("# HELP iscsi_target_operations Number of operations\n"
	       "# TYPE iscsi_target_operations counter\n");
	CTLSTAT_PROMETHEUS_LOOP(operations);
	printf("# HELP iscsi_target_time Cumulative operation time in us\n"
	       "# TYPE iscsi_target_time counter\n");
	CTLSTAT_PROMETHEUS_TIMELOOP(time);
	printf("# HELP iscsi_target_dma_time Cumulative DMA time in us\n"
	       "# TYPE iscsi_target_dma_time counter\n");
	CTLSTAT_PROMETHEUS_TIMELOOP(dma_time);

	for (i = 0; i < targdata.ntargets; i++)
		free(targdata.targets[i]);
	free(targdata.target);
	free(targdata.targets);

	fflush(stdout);
}

static void
ctlstat_standard(struct ctlstat_context *ctx) {
	long double etime;
	uint64_t delta_jiffies, delta_idle;
	long double cpu_percentage;
	int i, j, n;

	cpu_percentage = 0;

	if (F_CPU(ctx) && (getcpu(&ctx->cur_cpu) != 0))
		errx(1, "error returned from getcpu()");

	etime = ctx->cur_time.tv_sec - ctx->prev_time.tv_sec +
	    (ctx->prev_time.tv_nsec - ctx->cur_time.tv_nsec) * 1e-9;

	if (F_CPU(ctx)) {
		ctx->prev_total_jiffies = ctx->cur_total_jiffies;
		ctx->cur_total_jiffies = ctx->cur_cpu.user +
		    ctx->cur_cpu.nice + ctx->cur_cpu.system +
		    ctx->cur_cpu.intr + ctx->cur_cpu.idle;
		delta_jiffies = ctx->cur_total_jiffies;
		if (F_FIRST(ctx) == 0)
			delta_jiffies -= ctx->prev_total_jiffies;
		ctx->prev_idle = ctx->cur_idle;
		ctx->cur_idle = ctx->cur_cpu.idle;
		delta_idle = ctx->cur_idle - ctx->prev_idle;

		cpu_percentage = delta_jiffies - delta_idle;
		cpu_percentage /= delta_jiffies;
		cpu_percentage *= 100;
	}

	if (F_HDR(ctx)) {
		ctx->header_interval--;
		if (ctx->header_interval <= 0) {
			if (F_CPU(ctx))
				fprintf(stdout, " CPU");
			if (F_TOTALS(ctx)) {
				fprintf(stdout, "%s     Read       %s"
					"    Write       %s    Total\n",
					(F_TIMEVAL(ctx) != 0) ? "      " : "",
					(F_TIMEVAL(ctx) != 0) ? "      " : "",
					(F_TIMEVAL(ctx) != 0) ? "      " : "");
				n = 3;
			} else {
				for (i = n = 0; i < min(ctl_stat_bits,
				     ctx->cur_items); i++) {
					int item;

					/*
					 * Obviously this won't work with
					 * LUN numbers greater than a signed
					 * integer.
					 */
					item = (int)ctx->cur_stats[i].item;

					if (F_MASK(ctx) &&
					    bit_test(ctx->item_mask, item) == 0)
						continue;
					fprintf(stdout, "%15.6s%d %s",
					    F_PORTS(ctx) ? "port" : "lun", item,
					    (F_TIMEVAL(ctx) != 0) ? "     " : "");
					if (++n >= ctx->numdevs)
						break;
				}
				fprintf(stdout, "\n");
			}
			if (F_CPU(ctx))
				fprintf(stdout, "    ");
			for (i = 0; i < n; i++)
				fprintf(stdout, "%s KB/t   %s MB/s",
					(F_TIMEVAL(ctx) != 0) ? "    ms" : "",
					(F_DMA(ctx) == 0) ? "tps" : "dps");
			fprintf(stdout, "\n");
			ctx->header_interval = 20;
		}
	}

	if (F_CPU(ctx))
		fprintf(stdout, "%3.0Lf%%", cpu_percentage);
	if (F_TOTALS(ctx) != 0) {
		long double mbsec[3];
		long double kb_per_transfer[3];
		long double transfers_per_sec[3];
		long double ms_per_transfer[3];
		long double ms_per_dma[3];
		long double dmas_per_sec[3];

		for (i = 0; i < 3; i++)
			ctx->prev_total_stats[i] = ctx->cur_total_stats[i];

		memset(&ctx->cur_total_stats, 0, sizeof(ctx->cur_total_stats));

		/* Use macros to make the next loop more readable. */
#define	ADD_STATS_BYTES(st, i, j) \
	ctx->cur_total_stats[st].bytes[j] += \
	    ctx->cur_stats[i].bytes[j]
#define	ADD_STATS_OPERATIONS(st, i, j) \
	ctx->cur_total_stats[st].operations[j] += \
	    ctx->cur_stats[i].operations[j]
#define	ADD_STATS_DMAS(st, i, j) \
	ctx->cur_total_stats[st].dmas[j] += \
	    ctx->cur_stats[i].dmas[j]
#define	ADD_STATS_TIME(st, i, j) \
	bintime_add(&ctx->cur_total_stats[st].time[j], \
	    &ctx->cur_stats[i].time[j])
#define	ADD_STATS_DMA_TIME(st, i, j) \
	bintime_add(&ctx->cur_total_stats[st].dma_time[j], \
	    &ctx->cur_stats[i].dma_time[j])

		for (i = 0; i < ctx->cur_items; i++) {
			if (F_MASK(ctx) && bit_test(ctx->item_mask,
			    (int)ctx->cur_stats[i].item) == 0)
				continue;
			for (j = 0; j < CTL_STATS_NUM_TYPES; j++) {
				ADD_STATS_BYTES(2, i, j);
				ADD_STATS_OPERATIONS(2, i, j);
				ADD_STATS_DMAS(2, i, j);
				ADD_STATS_TIME(2, i, j);
				ADD_STATS_DMA_TIME(2, i, j);
			}
			ADD_STATS_BYTES(0, i, CTL_STATS_READ);
			ADD_STATS_OPERATIONS(0, i, CTL_STATS_READ);
			ADD_STATS_DMAS(0, i, CTL_STATS_READ);
			ADD_STATS_TIME(0, i, CTL_STATS_READ);
			ADD_STATS_DMA_TIME(0, i, CTL_STATS_READ);

			ADD_STATS_BYTES(1, i, CTL_STATS_WRITE);
			ADD_STATS_OPERATIONS(1, i, CTL_STATS_WRITE);
			ADD_STATS_DMAS(1, i, CTL_STATS_WRITE);
			ADD_STATS_TIME(1, i, CTL_STATS_WRITE);
			ADD_STATS_DMA_TIME(1, i, CTL_STATS_WRITE);
		}

		for (i = 0; i < 3; i++) {
			compute_stats(&ctx->cur_total_stats[i],
				F_FIRST(ctx) ? NULL : &ctx->prev_total_stats[i],
				etime, &mbsec[i], &kb_per_transfer[i],
				&transfers_per_sec[i],
				&ms_per_transfer[i], &ms_per_dma[i],
				&dmas_per_sec[i]);
			if (F_DMA(ctx) != 0)
				fprintf(stdout, " %5.1Lf",
					ms_per_dma[i]);
			else if (F_TIMEVAL(ctx) != 0)
				fprintf(stdout, " %5.1Lf",
					ms_per_transfer[i]);
			fprintf(stdout, " %4.0Lf %5.0Lf %4.0Lf",
				kb_per_transfer[i],
				(F_DMA(ctx) == 0) ? transfers_per_sec[i] :
				dmas_per_sec[i], mbsec[i]);
		}
	} else {
		for (i = n = 0; i < min(ctl_stat_bits, ctx->cur_items); i++) {
			long double mbsec, kb_per_transfer;
			long double transfers_per_sec;
			long double ms_per_transfer;
			long double ms_per_dma;
			long double dmas_per_sec;

			if (F_MASK(ctx) && bit_test(ctx->item_mask,
			    (int)ctx->cur_stats[i].item) == 0)
				continue;
			for (j = 0; j < ctx->prev_items; j++) {
				if (ctx->prev_stats[j].item ==
				    ctx->cur_stats[i].item)
					break;
			}
			if (j >= ctx->prev_items)
				j = -1;
			compute_stats(&ctx->cur_stats[i],
			    j >= 0 ? &ctx->prev_stats[j] : NULL,
			    etime, &mbsec, &kb_per_transfer,
			    &transfers_per_sec, &ms_per_transfer,
			    &ms_per_dma, &dmas_per_sec);
			if (F_DMA(ctx))
				fprintf(stdout, " %5.1Lf",
					ms_per_dma);
			else if (F_TIMEVAL(ctx) != 0)
				fprintf(stdout, " %5.1Lf",
					ms_per_transfer);
			fprintf(stdout, " %4.0Lf %5.0Lf %4.0Lf",
				kb_per_transfer, (F_DMA(ctx) == 0) ?
				transfers_per_sec : dmas_per_sec, mbsec);
			if (++n >= ctx->numdevs)
				break;
		}
	}
}

int
main(int argc, char **argv)
{
	int c;
	int count, waittime;
	int fd, retval;
	size_t size;
	struct ctlstat_context ctx;
	struct ctl_io_stats *tmp_stats;

	/* default values */
	retval = 0;
	waittime = 1;
	count = -1;
	memset(&ctx, 0, sizeof(ctx));
	ctx.numdevs = 3;
	ctx.mode = CTLSTAT_MODE_STANDARD;
	ctx.flags |= CTLSTAT_FLAG_CPU;
	ctx.flags |= CTLSTAT_FLAG_FIRST_RUN;
	ctx.flags |= CTLSTAT_FLAG_HEADER;

	size = sizeof(ctl_stat_bits);
	if (sysctlbyname("kern.cam.ctl.max_luns", &ctl_stat_bits, &size, NULL,
	    0) == -1) {
		/* Backward compatibility for where the sysctl wasn't exposed */
		ctl_stat_bits = 1024;
	}
	ctx.item_mask = bit_alloc(ctl_stat_bits);
	if (ctx.item_mask == NULL)
		err(1, "bit_alloc() failed");

	while ((c = getopt(argc, argv, ctlstat_opts)) != -1) {
		switch (c) {
		case 'C':
			ctx.flags &= ~CTLSTAT_FLAG_CPU;
			break;
		case 'c':
			count = atoi(optarg);
			break;
		case 'd':
			ctx.flags |= CTLSTAT_FLAG_DMA_TIME;
			break;
		case 'D':
			ctx.mode = CTLSTAT_MODE_DUMP;
			waittime = 30;
			break;
		case 'h':
			ctx.flags &= ~CTLSTAT_FLAG_HEADER;
			break;
		case 'j':
			ctx.mode = CTLSTAT_MODE_JSON;
			waittime = 30;
			break;
		case 'l': {
			int cur_lun;

			cur_lun = atoi(optarg);
			if (cur_lun > ctl_stat_bits)
				errx(1, "Invalid LUN number %d", cur_lun);

			if (!F_MASK(&ctx))
				ctx.numdevs = 1;
			else
				ctx.numdevs++;
			bit_set(ctx.item_mask, cur_lun);
			ctx.flags |= CTLSTAT_FLAG_MASK;
			ctx.flags |= CTLSTAT_FLAG_LUNS;
			break;
		}
		case 'n':
			ctx.numdevs = atoi(optarg);
			break;
		case 'p': {
			int cur_port;

			cur_port = atoi(optarg);
			if (cur_port > ctl_stat_bits)
				errx(1, "Invalid port number %d", cur_port);

			if (!F_MASK(&ctx))
				ctx.numdevs = 1;
			else
				ctx.numdevs++;
			bit_set(ctx.item_mask, cur_port);
			ctx.flags |= CTLSTAT_FLAG_MASK;
			ctx.flags |= CTLSTAT_FLAG_PORTS;
			break;
		}
		case 'P':
			ctx.mode = CTLSTAT_MODE_PROMETHEUS;
			break;
		case 't':
			ctx.flags |= CTLSTAT_FLAG_TOTALS;
			break;
		case 'w':
			waittime = atoi(optarg);
			break;
		default:
			retval = 1;
			usage(retval);
			exit(retval);
			break;
		}
	}

	if (F_LUNS(&ctx) && F_PORTS(&ctx))
		errx(1, "Options -p and -l are exclusive.");

	if (ctx.mode == CTLSTAT_MODE_PROMETHEUS) {
		if ((count != -1) ||
			(waittime != 1) ||
			/* NB: -P could be compatible with -t in the future */
			(ctx.flags & CTLSTAT_FLAG_TOTALS))
		{
			errx(1, "Option -P is exclusive with -c, -w, and -t");
		}
		count = 1;
	}

	if (!F_LUNS(&ctx) && !F_PORTS(&ctx)) {
		if (F_TOTALS(&ctx))
			ctx.flags |= CTLSTAT_FLAG_PORTS;
		else
			ctx.flags |= CTLSTAT_FLAG_LUNS;
	}

	if ((fd = open(CTL_DEFAULT_DEV, O_RDWR)) == -1)
		err(1, "cannot open %s", CTL_DEFAULT_DEV);

	for (;count != 0;) {
		tmp_stats = ctx.prev_stats;
		ctx.prev_stats = ctx.cur_stats;
		ctx.cur_stats = tmp_stats;
		c = ctx.prev_alloc;
		ctx.prev_alloc = ctx.cur_alloc;
		ctx.cur_alloc = c;
		c = ctx.prev_items;
		ctx.prev_items = ctx.cur_items;
		ctx.cur_items = c;
		ctx.prev_time = ctx.cur_time;
		ctx.prev_cpu = ctx.cur_cpu;
		if (getstats(fd, &ctx.cur_alloc, &ctx.cur_items,
		    &ctx.cur_stats, &ctx.cur_time, &ctx.flags) != 0)
			errx(1, "error returned from getstats()");

		switch(ctx.mode) {
		case CTLSTAT_MODE_STANDARD:
			ctlstat_standard(&ctx);
			break;
		case CTLSTAT_MODE_DUMP:
			ctlstat_dump(&ctx);
			break;
		case CTLSTAT_MODE_JSON:
			ctlstat_json(&ctx);
			break;
		case CTLSTAT_MODE_PROMETHEUS:
			ctlstat_prometheus(fd, &ctx);
			break;
		default:
			break;
		}

		fprintf(stdout, "\n");
		fflush(stdout);
		ctx.flags &= ~CTLSTAT_FLAG_FIRST_RUN;
		if (count != 1)
			sleep(waittime);
		if (count > 0)
			count--;
	}

	exit (retval);
}

/*
 * vim: ts=8
 */