IOS_LATENCY = 1,
IOS_QUEUES = 2,
IOS_L_HISTO = 3,
+ IOS_RQ_HISTO = 4,
IOS_COUNT, /* always last element */
};
#define IOS_LATENCY_M (1ULL << IOS_LATENCY)
#define IOS_QUEUES_M (1ULL << IOS_QUEUES)
#define IOS_L_HISTO_M (1ULL << IOS_L_HISTO)
+#define IOS_RQ_HISTO_M (1ULL << IOS_RQ_HISTO)
+
+/* Mask of all the histo bits */
+#define IOS_ANYHISTO_M (IOS_L_HISTO_M | IOS_RQ_HISTO_M)
+
+/*
+ * Lookup table for iostat flags to nvlist names. Basically a list
+ * of all the nvlists a flag requires. Also specifies the order in
+ * which data gets printed in zpool iostat.
+ */
+static const char *vsx_type_to_nvlist[IOS_COUNT][11] = {
+ [IOS_L_HISTO] = {
+ ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
+ NULL},
+ [IOS_LATENCY] = {
+ ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
+ ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
+ NULL},
+ [IOS_QUEUES] = {
+ ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
+ ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
+ ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
+ ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
+ ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
+ NULL},
+ [IOS_RQ_HISTO] = {
+ ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO,
+ ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO,
+ ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO,
+ ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO,
+ ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO,
+ ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO,
+ ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO,
+ ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO,
+ ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO,
+ ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO,
+ NULL},
+};
+
+
+/*
+ * Given a cb->cb_flags with a histogram bit set, return the iostat_type.
+ * Right now, only one histo bit is ever set at one time, so we can
+ * just do a highbit64(a)
+ */
+#define IOS_HISTO_IDX(a) (highbit64(a & IOS_ANYHISTO_M) - 1)
typedef struct zpool_command {
const char *name;
"[-R root] [-F [-n]]\n"
"\t <pool | id> [newpool]\n"));
case HELP_IOSTAT:
- return (gettext("\tiostat [-T d | u] [-ghHLpPvy] [[-lq]|-w]\n"
+ return (gettext("\tiostat [-T d | u] [-ghHLpPvy] "
+ "[[-lq]|[-r|-w]]\n"
"\t [[pool ...]|[pool vdev ...]|[vdev ...]] "
"[interval [count]]\n"));
case HELP_LABELCLEAR:
{NULL}},
[IOS_L_HISTO] = {{"total_wait", 2}, {"disk_wait", 2},
{"sync_queue", 2}, {"async_queue", 2}, {NULL}},
+ [IOS_RQ_HISTO] = {{"sync_read", 2}, {"sync_write", 2},
+ {"async_read", 2}, {"async_write", 2}, {"scrub", 2}, {NULL}},
+
};
/* Shorthand - if "columns" field not set, default to 1 column */
{"activ"}, {"pend"}, {"activ"}, {"pend"}, {"activ"}, {NULL}},
[IOS_L_HISTO] = {{"read"}, {"write"}, {"read"}, {"write"}, {"read"},
{"write"}, {"read"}, {"write"}, {"scrub"}, {NULL}},
+ [IOS_RQ_HISTO] = {{"ind"}, {"agg"}, {"ind"}, {"agg"}, {"ind"}, {"agg"},
+ {"ind"}, {"agg"}, {"ind"}, {"agg"}, {NULL}},
+};
+
+static const char *histo_to_title[] = {
+ [IOS_L_HISTO] = "latency",
+ [IOS_RQ_HISTO] = "req_size",
};
/*
return (i);
}
+/*
+ * Return the number of strings in a null-terminated string array.
+ * For example:
+ *
+ * const char foo[] = {"bar", "baz", NULL}
+ *
+ * returns 2
+ */
+static uint64_t
+str_array_len(const char *array[])
+{
+ uint64_t i = 0;
+ while (array[i])
+ i++;
+
+ return (i);
+}
+
+
/*
* Return a default column width for default/latency/queue columns. This does
* not include histograms, which have their columns autosized.
uint64_t f;
int idx;
const name_and_columns_t *labels;
+ const char *title;
+
+
+ if (cb->cb_flags & IOS_ANYHISTO_M) {
+ title = histo_to_title[IOS_HISTO_IDX(cb->cb_flags)];
+ } else if (cb->cb_vdev_names_count) {
+ title = "vdev";
+ } else {
+ title = "pool";
+ }
+
+ namewidth = MAX(MAX(strlen(title), cb->cb_namewidth),
+ name ? strlen(name) : 0);
- if (cb->cb_flags & IOS_L_HISTO_M)
- namewidth = MAX(cb->cb_namewidth, strlen("latency"));
- else
- namewidth = cb->cb_namewidth;
if (name) {
- namewidth = MAX(cb->cb_namewidth, strlen(name));
printf("%-*s", namewidth, name);
} else {
for (i = 0; i < namewidth; i++)
const char *histo_vdev_name)
{
unsigned int namewidth;
- uint64_t flags = cb->cb_flags;
+ const char *title;
- if (flags & IOS_L_HISTO_M)
- namewidth = MAX(cb->cb_namewidth, strlen("latency"));
- else
- namewidth = cb->cb_namewidth;
+ if (cb->cb_flags & IOS_ANYHISTO_M) {
+ title = histo_to_title[IOS_HISTO_IDX(cb->cb_flags)];
+ } else if (cb->cb_vdev_names_count) {
+ title = "vdev";
+ } else {
+ title = "pool";
+ }
- if (flags & IOS_L_HISTO_M)
+ namewidth = MAX(MAX(strlen(title), cb->cb_namewidth),
+ histo_vdev_name ? strlen(histo_vdev_name) : 0);
+
+ if (histo_vdev_name)
printf("%-*s", namewidth, histo_vdev_name);
else
printf("%*s", namewidth, "");
+
print_iostat_labels(cb, force_column_width, iostat_top_labels);
- printf("%-*s", namewidth, flags & IOS_L_HISTO_M ? "latency" :
- cb->cb_vdev_names_count ? "vdev" : "pool");
+ printf("%-*s", namewidth, title);
print_iostat_labels(cb, force_column_width, iostat_bottom_labels);
uint64_t val;
enum zfs_nicenum_format format;
unsigned int buckets;
+ unsigned int start_bucket;
if (cb->cb_literal)
format = ZFS_NICENUM_RAW;
/* All these histos are the same size, so just use nva[0].count */
buckets = nva[0].count;
- for (j = 0; j < buckets; j++) {
- /* Ending range of this bucket */
- val = (1UL << (j + 1)) - 1;
+ if (cb->cb_flags & IOS_RQ_HISTO_M) {
+ /* Start at 512 - req size should never be lower than this */
+ start_bucket = 9;
+ } else {
+ start_bucket = 0;
+ }
+ for (j = start_bucket; j < buckets; j++) {
/* Print histogram bucket label */
- zfs_nicetime(val, buf, sizeof (buf));
+ if (cb->cb_flags & IOS_L_HISTO_M) {
+ /* Ending range of this bucket */
+ val = (1UL << (j + 1)) - 1;
+ zfs_nicetime(val, buf, sizeof (buf));
+ } else {
+ /* Request size (starting range of bucket) */
+ val = (1UL << j);
+ zfs_nicenum(val, buf, sizeof (buf));
+ }
+
if (cb->cb_scripted)
printf("%llu", (u_longlong_t) val);
else
unsigned int column_width;
unsigned int namewidth;
unsigned int entire_width;
-
- const char *names[] = {
- ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
- };
+ enum iostat_type type;
struct stat_array *nva;
- nva = calc_and_alloc_stats_ex(names, ARRAY_SIZE(names), oldnv, newnv);
+ const char **names;
+ unsigned int names_len;
+
+ /* What type of histo are we? */
+ type = IOS_HISTO_IDX(cb->cb_flags);
+
+ /* Get NULL-terminated array of nvlist names for our histo */
+ names = vsx_type_to_nvlist[type];
+ names_len = str_array_len(names); /* num of names */
+
+ nva = calc_and_alloc_stats_ex(names, names_len, oldnv, newnv);
if (cb->cb_literal) {
column_width = MAX(5,
- (unsigned int) log10(stat_histo_max(nva,
- ARRAY_SIZE(names))) + 1);
+ (unsigned int) log10(stat_histo_max(nva, names_len)) + 1);
} else {
column_width = 5;
}
- namewidth = MAX(cb->cb_namewidth, strlen("latency"));
+ namewidth = MAX(cb->cb_namewidth,
+ strlen(histo_to_title[IOS_HISTO_IDX(cb->cb_flags)]));
/*
* Calculate the entire line width of what we're printing. The
/* |__________| <--- entire_width */
/* */
entire_width = namewidth + (column_width + 2) *
- label_array_len(iostat_bottom_labels[IOS_L_HISTO]);
+ label_array_len(iostat_bottom_labels[type]);
if (cb->cb_scripted)
printf("%s\n", name);
else
print_iostat_header_impl(cb, column_width, name);
- print_iostat_histo(nva, ARRAY_SIZE(names), cb, column_width,
+ print_iostat_histo(nva, names_len, cb, column_width,
namewidth, scale);
- free_calc_stats(nva, ARRAY_SIZE(names));
+ free_calc_stats(nva, names_len);
if (!cb->cb_scripted)
print_solid_separator(entire_width);
}
* Print the vdev name unless it's is a histogram. Histograms
* display the vdev name in the header itself.
*/
- if (!(cb->cb_flags & IOS_L_HISTO_M)) {
+ if (!(cb->cb_flags & IOS_ANYHISTO_M)) {
if (cb->cb_scripted) {
printf("%s", name);
} else {
/* Calculate our scaling factor */
tdelta = newvs->vs_timestamp - oldvs->vs_timestamp;
- if ((oldvs->vs_timestamp == 0) && (cb->cb_flags & IOS_L_HISTO_M)) {
+ if ((oldvs->vs_timestamp == 0) && (cb->cb_flags & IOS_ANYHISTO_M)) {
/*
* If we specify printing histograms with no time interval, then
* print the histogram numbers over the entire lifetime of the
print_iostat_latency(cb, oldnv, newnv, scale);
if (cb->cb_flags & IOS_QUEUES_M)
print_iostat_queues(cb, oldnv, newnv, scale);
- if (cb->cb_flags & IOS_L_HISTO_M) {
+ if (cb->cb_flags & IOS_ANYHISTO_M) {
printf("\n");
print_iostat_histos(cb, oldnv, newnv, scale, name);
}
- if (!(cb->cb_flags & IOS_L_HISTO_M))
+ if (!(cb->cb_flags & IOS_ANYHISTO_M))
printf("\n");
free(calcvs);
*/
if (num_logs(newnv) > 0) {
- if ((!(cb->cb_flags & IOS_L_HISTO_M)) && !cb->cb_scripted &&
+ if ((!(cb->cb_flags & IOS_ANYHISTO_M)) && !cb->cb_scripted &&
!cb->cb_vdev_names) {
print_iostat_dashes(cb, 0, "logs");
}
return (ret);
if (children > 0) {
- if ((!(cb->cb_flags & IOS_L_HISTO_M)) && !cb->cb_scripted &&
+ if ((!(cb->cb_flags & IOS_ANYHISTO_M)) && !cb->cb_scripted &&
!cb->cb_vdev_names) {
print_iostat_dashes(cb, 0, "cache");
}
ret = print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot,
cb, 0);
- if ((ret != 0) && !(cb->cb_flags & IOS_L_HISTO_M) && !cb->cb_scripted &&
- cb->cb_verbose && !cb->cb_vdev_names_count)
- print_iostat_separator(cb);
+ if ((ret != 0) && !(cb->cb_flags & IOS_ANYHISTO_M) &&
+ !cb->cb_scripted && cb->cb_verbose && !cb->cb_vdev_names_count) {
+ print_iostat_separator(cb);
+ }
return (ret);
}
uint64_t flags = 0;
int i, j;
- /*
- * Lookup table for extended iostat flags to nvlist names.
- * Basically a list of all the nvpairs a flag requires.
- */
- static const char *vsx_type_to_nvlist[IOS_COUNT][10] = {
- [IOS_L_HISTO] = {
- ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
- NULL},
- [IOS_LATENCY] = {
- ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
- ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
- NULL},
- [IOS_QUEUES] = {
- ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
- ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
- ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
- ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
- ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
- NULL}
- };
-
config = zpool_get_config(zhp, NULL);
verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
&nvroot) == 0);
/*
- * zpool iostat [-ghHLpPvy] [[-lq]-w] [-n name] [-T d|u]
+ * zpool iostat [-ghHLpPvy] [[-lq]|[-r|-w]] [-n name] [-T d|u]
* [[ pool ...]|[pool vdev ...]|[vdev ...]]
* [interval [count]]
*
* by a single tab.
* -l Display average latency
* -q Display queue depths
- * -w Display histograms
+ * -w Display latency histograms
+ * -r Display request size histogram
* -T Display a timestamp in date(1) or Unix format
*
* This command can be tricky because we want to be able to deal with pool
unsigned long count = 0;
zpool_list_t *list;
boolean_t verbose = B_FALSE;
- boolean_t latency = B_FALSE, histo = B_FALSE;
+ boolean_t latency = B_FALSE, l_histo = B_FALSE, rq_histo = B_FALSE;
boolean_t queues = B_FALSE, parsable = B_FALSE, scripted = B_FALSE;
boolean_t omit_since_boot = B_FALSE;
boolean_t guid = B_FALSE;
/* Used for printing error message */
const char flag_to_arg[] = {[IOS_LATENCY] = 'l', [IOS_QUEUES] = 'q',
- [IOS_L_HISTO] = 'w'};
+ [IOS_L_HISTO] = 'w', [IOS_RQ_HISTO] = 'r'};
uint64_t unsupported_flags;
/* check options */
- while ((c = getopt(argc, argv, "gLPT:vyhplqwH")) != -1) {
+ while ((c = getopt(argc, argv, "gLPT:vyhplqrwH")) != -1) {
switch (c) {
case 'g':
guid = B_TRUE;
scripted = B_TRUE;
break;
case 'w':
- histo = B_TRUE;
+ l_histo = B_TRUE;
+ break;
+ case 'r':
+ rq_histo = B_TRUE;
break;
case 'y':
omit_since_boot = B_TRUE;
return (1);
}
- if (histo && (queues || latency)) {
+ if ((l_histo || rq_histo) && (queues || latency)) {
+ pool_list_free(list);
+ (void) fprintf(stderr,
+ gettext("[-r|-w] isn't allowed with [-q|-l]\n"));
+ usage(B_FALSE);
+ return (1);
+ }
+
+ if (l_histo && rq_histo) {
pool_list_free(list);
(void) fprintf(stderr,
- gettext("-w isn't allowed with [-q|-l]\n"));
+ gettext("Only one of [-r|-w] can be passed at a time\n"));
usage(B_FALSE);
return (1);
}
*/
cb.cb_list = list;
- if (histo) {
+ if (l_histo) {
/*
* Histograms tables look out of place when you try to display
* them with the other stats, so make a rule that you can only
* print histograms by themselves.
*/
cb.cb_flags = IOS_L_HISTO_M;
+ } else if (rq_histo) {
+ cb.cb_flags = IOS_RQ_HISTO_M;
} else {
cb.cb_flags = IOS_DEFAULT_M;
if (latency)
*/
if (((++cb.cb_iteration == 1 && !skip) ||
(skip != verbose)) &&
- (!(cb.cb_flags & IOS_L_HISTO_M)) &&
+ (!(cb.cb_flags & IOS_ANYHISTO_M)) &&
!cb.cb_scripted)
print_iostat_header(&cb);
* we also want an ending separator.
*/
if (((npools > 1 && !verbose &&
- !(cb.cb_flags & IOS_L_HISTO_M)) ||
- (!(cb.cb_flags & IOS_L_HISTO_M) &&
+ !(cb.cb_flags & IOS_ANYHISTO_M)) ||
+ (!(cb.cb_flags & IOS_ANYHISTO_M) &&
cb.cb_vdev_names_count)) &&
!cb.cb_scripted) {
print_iostat_separator(&cb);
projects / mirror_zfs.git / commitdiff