When invoked by inetd, ctlstat -P will now produce output suitable for ingestion into Prometheus. It's a drop-in replacement for https://github.com/Gandi/ctld_exporter, except that it doesn't report the number of initiators per target, and it does report time and dma_time. MFC after: 2 weeks Sponsored by: Axcient Relnotes: yes Reviewed by: bapt, bcr Differential Revision: https://reviews.freebsd.org/D29901
959 lines
27 KiB
C
959 lines
27 KiB
C
/*-
|
|
* 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
|
|
*/
|