1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2004, 2008, 2009 Silicon Graphics International Corp. 5 * Copyright (c) 2017 Alexander Motin <mav@FreeBSD.org> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions, and the following disclaimer, 13 * without modification. 14 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 15 * substantially similar to the "NO WARRANTY" disclaimer below 16 * ("Disclaimer") and any redistribution must be conditioned upon 17 * including a substantially similar Disclaimer requirement for further 18 * binary redistribution. 19 * 20 * NO WARRANTY 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 30 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGES. 32 * 33 * $Id: //depot/users/kenm/FreeBSD-test2/usr.bin/ctlstat/ctlstat.c#4 $ 34 */ 35 /* 36 * CAM Target Layer statistics program 37 * 38 * Authors: Ken Merry <ken@FreeBSD.org>, Will Andrews <will@FreeBSD.org> 39 */ 40 41 #include <sys/cdefs.h> 42 __FBSDID("$FreeBSD$"); 43 44 #include <sys/param.h> 45 #include <sys/callout.h> 46 #include <sys/ioctl.h> 47 #include <sys/queue.h> 48 #include <sys/resource.h> 49 #include <sys/sbuf.h> 50 #include <sys/socket.h> 51 #include <sys/sysctl.h> 52 #include <sys/time.h> 53 #include <assert.h> 54 #include <bsdxml.h> 55 #include <malloc_np.h> 56 #include <stdint.h> 57 #include <stdio.h> 58 #include <stdlib.h> 59 #include <unistd.h> 60 #include <fcntl.h> 61 #include <inttypes.h> 62 #include <getopt.h> 63 #include <string.h> 64 #include <errno.h> 65 #include <err.h> 66 #include <ctype.h> 67 #include <bitstring.h> 68 #include <cam/scsi/scsi_all.h> 69 #include <cam/ctl/ctl.h> 70 #include <cam/ctl/ctl_io.h> 71 #include <cam/ctl/ctl_scsi_all.h> 72 #include <cam/ctl/ctl_util.h> 73 #include <cam/ctl/ctl_backend.h> 74 #include <cam/ctl/ctl_ioctl.h> 75 76 /* 77 * The default amount of space we allocate for stats storage space. 78 * We dynamically allocate more if needed. 79 */ 80 #define CTL_STAT_NUM_ITEMS 256 81 82 static int ctl_stat_bits; 83 84 static const char *ctlstat_opts = "Cc:DPdhjl:n:p:tw:"; 85 static const char *ctlstat_usage = "Usage: ctlstat [-CDPdjht] [-l lunnum]" 86 "[-c count] [-n numdevs] [-w wait]\n"; 87 88 struct ctl_cpu_stats { 89 uint64_t user; 90 uint64_t nice; 91 uint64_t system; 92 uint64_t intr; 93 uint64_t idle; 94 }; 95 96 typedef enum { 97 CTLSTAT_MODE_STANDARD, 98 CTLSTAT_MODE_DUMP, 99 CTLSTAT_MODE_JSON, 100 CTLSTAT_MODE_PROMETHEUS, 101 } ctlstat_mode_types; 102 103 #define CTLSTAT_FLAG_CPU (1 << 0) 104 #define CTLSTAT_FLAG_HEADER (1 << 1) 105 #define CTLSTAT_FLAG_FIRST_RUN (1 << 2) 106 #define CTLSTAT_FLAG_TOTALS (1 << 3) 107 #define CTLSTAT_FLAG_DMA_TIME (1 << 4) 108 #define CTLSTAT_FLAG_TIME_VALID (1 << 5) 109 #define CTLSTAT_FLAG_MASK (1 << 6) 110 #define CTLSTAT_FLAG_LUNS (1 << 7) 111 #define CTLSTAT_FLAG_PORTS (1 << 8) 112 #define F_CPU(ctx) ((ctx)->flags & CTLSTAT_FLAG_CPU) 113 #define F_HDR(ctx) ((ctx)->flags & CTLSTAT_FLAG_HEADER) 114 #define F_FIRST(ctx) ((ctx)->flags & CTLSTAT_FLAG_FIRST_RUN) 115 #define F_TOTALS(ctx) ((ctx)->flags & CTLSTAT_FLAG_TOTALS) 116 #define F_DMA(ctx) ((ctx)->flags & CTLSTAT_FLAG_DMA_TIME) 117 #define F_TIMEVAL(ctx) ((ctx)->flags & CTLSTAT_FLAG_TIME_VALID) 118 #define F_MASK(ctx) ((ctx)->flags & CTLSTAT_FLAG_MASK) 119 #define F_LUNS(ctx) ((ctx)->flags & CTLSTAT_FLAG_LUNS) 120 #define F_PORTS(ctx) ((ctx)->flags & CTLSTAT_FLAG_PORTS) 121 122 struct ctlstat_context { 123 ctlstat_mode_types mode; 124 int flags; 125 struct ctl_io_stats *cur_stats, *prev_stats; 126 struct ctl_io_stats cur_total_stats[3], prev_total_stats[3]; 127 struct timespec cur_time, prev_time; 128 struct ctl_cpu_stats cur_cpu, prev_cpu; 129 uint64_t cur_total_jiffies, prev_total_jiffies; 130 uint64_t cur_idle, prev_idle; 131 bitstr_t *item_mask; 132 int cur_items, prev_items; 133 int cur_alloc, prev_alloc; 134 int numdevs; 135 int header_interval; 136 }; 137 138 struct cctl_portlist_data { 139 int level; 140 struct sbuf *cur_sb[32]; 141 int id; 142 int lun; 143 int ntargets; 144 char *target; 145 char **targets; 146 }; 147 148 #ifndef min 149 #define min(x,y) (((x) < (y)) ? (x) : (y)) 150 #endif 151 152 static void usage(int error); 153 static int getstats(int fd, int *alloc_items, int *num_items, 154 struct ctl_io_stats **xstats, struct timespec *cur_time, int *time_valid, 155 bool ports); 156 static int getcpu(struct ctl_cpu_stats *cpu_stats); 157 static void compute_stats(struct ctl_io_stats *cur_stats, 158 struct ctl_io_stats *prev_stats, 159 long double etime, long double *mbsec, 160 long double *kb_per_transfer, 161 long double *transfers_per_second, 162 long double *ms_per_transfer, 163 long double *ms_per_dma, 164 long double *dmas_per_second); 165 166 static void 167 usage(int error) 168 { 169 fputs(ctlstat_usage, error ? stderr : stdout); 170 } 171 172 static int 173 getstats(int fd, int *alloc_items, int *num_items, struct ctl_io_stats **stats, 174 struct timespec *cur_time, int *flags, bool ports) 175 { 176 struct ctl_get_io_stats get_stats; 177 int more_space_count = 0; 178 179 if (*alloc_items == 0) 180 *alloc_items = CTL_STAT_NUM_ITEMS; 181 retry: 182 if (*stats == NULL) 183 *stats = malloc(sizeof(**stats) * *alloc_items); 184 185 memset(&get_stats, 0, sizeof(get_stats)); 186 get_stats.alloc_len = *alloc_items * sizeof(**stats); 187 memset(*stats, 0, get_stats.alloc_len); 188 get_stats.stats = *stats; 189 190 if (ioctl(fd, ports ? CTL_GET_PORT_STATS : CTL_GET_LUN_STATS, 191 &get_stats) == -1) 192 err(1, "CTL_GET_*_STATS ioctl returned error"); 193 194 switch (get_stats.status) { 195 case CTL_SS_OK: 196 break; 197 case CTL_SS_ERROR: 198 err(1, "CTL_GET_*_STATS ioctl returned CTL_SS_ERROR"); 199 break; 200 case CTL_SS_NEED_MORE_SPACE: 201 if (more_space_count >= 2) 202 errx(1, "CTL_GET_*_STATS returned NEED_MORE_SPACE again"); 203 *alloc_items = get_stats.num_items * 5 / 4; 204 free(*stats); 205 *stats = NULL; 206 more_space_count++; 207 goto retry; 208 break; /* NOTREACHED */ 209 default: 210 errx(1, "CTL_GET_*_STATS ioctl returned unknown status %d", 211 get_stats.status); 212 break; 213 } 214 215 *num_items = get_stats.fill_len / sizeof(**stats); 216 cur_time->tv_sec = get_stats.timestamp.tv_sec; 217 cur_time->tv_nsec = get_stats.timestamp.tv_nsec; 218 if (get_stats.flags & CTL_STATS_FLAG_TIME_VALID) 219 *flags |= CTLSTAT_FLAG_TIME_VALID; 220 else 221 *flags &= ~CTLSTAT_FLAG_TIME_VALID; 222 223 return (0); 224 } 225 226 static int 227 getcpu(struct ctl_cpu_stats *cpu_stats) 228 { 229 long cp_time[CPUSTATES]; 230 size_t cplen; 231 232 cplen = sizeof(cp_time); 233 234 if (sysctlbyname("kern.cp_time", &cp_time, &cplen, NULL, 0) == -1) { 235 warn("sysctlbyname(kern.cp_time...) failed"); 236 return (1); 237 } 238 239 cpu_stats->user = cp_time[CP_USER]; 240 cpu_stats->nice = cp_time[CP_NICE]; 241 cpu_stats->system = cp_time[CP_SYS]; 242 cpu_stats->intr = cp_time[CP_INTR]; 243 cpu_stats->idle = cp_time[CP_IDLE]; 244 245 return (0); 246 } 247 248 static void 249 compute_stats(struct ctl_io_stats *cur_stats, 250 struct ctl_io_stats *prev_stats, long double etime, 251 long double *mbsec, long double *kb_per_transfer, 252 long double *transfers_per_second, long double *ms_per_transfer, 253 long double *ms_per_dma, long double *dmas_per_second) 254 { 255 uint64_t total_bytes = 0, total_operations = 0, total_dmas = 0; 256 struct bintime total_time_bt, total_dma_bt; 257 struct timespec total_time_ts, total_dma_ts; 258 int i; 259 260 bzero(&total_time_bt, sizeof(total_time_bt)); 261 bzero(&total_dma_bt, sizeof(total_dma_bt)); 262 bzero(&total_time_ts, sizeof(total_time_ts)); 263 bzero(&total_dma_ts, sizeof(total_dma_ts)); 264 for (i = 0; i < CTL_STATS_NUM_TYPES; i++) { 265 total_bytes += cur_stats->bytes[i]; 266 total_operations += cur_stats->operations[i]; 267 total_dmas += cur_stats->dmas[i]; 268 bintime_add(&total_time_bt, &cur_stats->time[i]); 269 bintime_add(&total_dma_bt, &cur_stats->dma_time[i]); 270 if (prev_stats != NULL) { 271 total_bytes -= prev_stats->bytes[i]; 272 total_operations -= prev_stats->operations[i]; 273 total_dmas -= prev_stats->dmas[i]; 274 bintime_sub(&total_time_bt, &prev_stats->time[i]); 275 bintime_sub(&total_dma_bt, &prev_stats->dma_time[i]); 276 } 277 } 278 279 *mbsec = total_bytes; 280 *mbsec /= 1024 * 1024; 281 if (etime > 0.0) 282 *mbsec /= etime; 283 else 284 *mbsec = 0; 285 *kb_per_transfer = total_bytes; 286 *kb_per_transfer /= 1024; 287 if (total_operations > 0) 288 *kb_per_transfer /= total_operations; 289 else 290 *kb_per_transfer = 0; 291 *transfers_per_second = total_operations; 292 *dmas_per_second = total_dmas; 293 if (etime > 0.0) { 294 *transfers_per_second /= etime; 295 *dmas_per_second /= etime; 296 } else { 297 *transfers_per_second = 0; 298 *dmas_per_second = 0; 299 } 300 301 bintime2timespec(&total_time_bt, &total_time_ts); 302 bintime2timespec(&total_dma_bt, &total_dma_ts); 303 if (total_operations > 0) { 304 /* 305 * Convert the timespec to milliseconds. 306 */ 307 *ms_per_transfer = total_time_ts.tv_sec * 1000; 308 *ms_per_transfer += total_time_ts.tv_nsec / 1000000; 309 *ms_per_transfer /= total_operations; 310 } else 311 *ms_per_transfer = 0; 312 313 if (total_dmas > 0) { 314 /* 315 * Convert the timespec to milliseconds. 316 */ 317 *ms_per_dma = total_dma_ts.tv_sec * 1000; 318 *ms_per_dma += total_dma_ts.tv_nsec / 1000000; 319 *ms_per_dma /= total_dmas; 320 } else 321 *ms_per_dma = 0; 322 } 323 324 /* The dump_stats() and json_stats() functions perform essentially the same 325 * purpose, but dump the statistics in different formats. JSON is more 326 * conducive to programming, however. 327 */ 328 329 #define PRINT_BINTIME(bt) \ 330 printf("%jd.%06ju", (intmax_t)(bt).sec, \ 331 (uintmax_t)(((bt).frac >> 32) * 1000000 >> 32)) 332 static const char *iotypes[] = {"NO IO", "READ", "WRITE"}; 333 334 static void 335 ctlstat_dump(struct ctlstat_context *ctx) 336 { 337 int iotype, i, n; 338 struct ctl_io_stats *stats = ctx->cur_stats; 339 340 for (i = n = 0; i < ctx->cur_items;i++) { 341 if (F_MASK(ctx) && bit_test(ctx->item_mask, 342 (int)stats[i].item) == 0) 343 continue; 344 printf("%s %d\n", F_PORTS(ctx) ? "port" : "lun", stats[i].item); 345 for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) { 346 printf(" io type %d (%s)\n", iotype, iotypes[iotype]); 347 printf(" bytes %ju\n", (uintmax_t) 348 stats[i].bytes[iotype]); 349 printf(" operations %ju\n", (uintmax_t) 350 stats[i].operations[iotype]); 351 printf(" dmas %ju\n", (uintmax_t) 352 stats[i].dmas[iotype]); 353 printf(" io time "); 354 PRINT_BINTIME(stats[i].time[iotype]); 355 printf("\n dma time "); 356 PRINT_BINTIME(stats[i].dma_time[iotype]); 357 printf("\n"); 358 } 359 if (++n >= ctx->numdevs) 360 break; 361 } 362 } 363 364 static void 365 ctlstat_json(struct ctlstat_context *ctx) { 366 int iotype, i, n; 367 struct ctl_io_stats *stats = ctx->cur_stats; 368 369 printf("{\"%s\":[", F_PORTS(ctx) ? "ports" : "luns"); 370 for (i = n = 0; i < ctx->cur_items; i++) { 371 if (F_MASK(ctx) && bit_test(ctx->item_mask, 372 (int)stats[i].item) == 0) 373 continue; 374 printf("{\"num\":%d,\"io\":[", 375 stats[i].item); 376 for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) { 377 printf("{\"type\":\"%s\",", iotypes[iotype]); 378 printf("\"bytes\":%ju,", (uintmax_t) 379 stats[i].bytes[iotype]); 380 printf("\"operations\":%ju,", (uintmax_t) 381 stats[i].operations[iotype]); 382 printf("\"dmas\":%ju,", (uintmax_t) 383 stats[i].dmas[iotype]); 384 printf("\"io time\":"); 385 PRINT_BINTIME(stats[i].time[iotype]); 386 printf(",\"dma time\":"); 387 PRINT_BINTIME(stats[i].dma_time[iotype]); 388 printf("}"); 389 if (iotype < (CTL_STATS_NUM_TYPES - 1)) 390 printf(","); /* continue io array */ 391 } 392 printf("]}"); 393 if (++n >= ctx->numdevs) 394 break; 395 if (i < (ctx->cur_items - 1)) 396 printf(","); /* continue lun array */ 397 } 398 printf("]}"); 399 } 400 401 #define CTLSTAT_PROMETHEUS_LOOP(field, collector) \ 402 for (i = n = 0; i < ctx->cur_items; i++) { \ 403 if (F_MASK(ctx) && bit_test(ctx->item_mask, \ 404 (int)stats[i].item) == 0) \ 405 continue; \ 406 for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) { \ 407 int idx = stats[i].item; \ 408 /* \ 409 * Note that Prometheus considers a label value of "" \ 410 * to be the same as no label at all \ 411 */ \ 412 const char *target = ""; \ 413 if (strcmp(collector, "port") == 0 && \ 414 targdata.targets[idx] != NULL) \ 415 { \ 416 target = targdata.targets[idx]; \ 417 } \ 418 printf("iscsi_%s_" #field "{" \ 419 "%s=\"%u\",target=\"%s\",type=\"%s\"} %" PRIu64 \ 420 "\n", \ 421 collector, collector, \ 422 idx, target, iotypes[iotype], \ 423 stats[i].field[iotype]); \ 424 } \ 425 } \ 426 427 #define CTLSTAT_PROMETHEUS_TIMELOOP(field, collector) \ 428 for (i = n = 0; i < ctx->cur_items; i++) { \ 429 if (F_MASK(ctx) && bit_test(ctx->item_mask, \ 430 (int)stats[i].item) == 0) \ 431 continue; \ 432 for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; iotype++) { \ 433 uint64_t us; \ 434 struct timespec ts; \ 435 int idx = stats[i].item; \ 436 /* \ 437 * Note that Prometheus considers a label value of "" \ 438 * to be the same as no label at all \ 439 */ \ 440 const char *target = ""; \ 441 if (strcmp(collector, "port") == 0 && \ 442 targdata.targets[idx] != NULL) \ 443 { \ 444 target = targdata.targets[idx]; \ 445 } \ 446 bintime2timespec(&stats[i].field[iotype], &ts); \ 447 us = ts.tv_sec * 1000000 + ts.tv_nsec / 1000; \ 448 printf("iscsi_%s_" #field "{" \ 449 "%s=\"%u\",target=\"%s\",type=\"%s\"} %" PRIu64 \ 450 "\n", \ 451 collector, collector, \ 452 idx, target, iotypes[iotype], us); \ 453 } \ 454 } \ 455 456 static void 457 cctl_start_pelement(void *user_data, const char *name, const char **attr) 458 { 459 struct cctl_portlist_data* targdata = user_data; 460 461 targdata->level++; 462 if ((u_int)targdata->level >= (sizeof(targdata->cur_sb) / 463 sizeof(targdata->cur_sb[0]))) 464 errx(1, "%s: too many nesting levels, %zd max", __func__, 465 sizeof(targdata->cur_sb) / sizeof(targdata->cur_sb[0])); 466 467 targdata->cur_sb[targdata->level] = sbuf_new_auto(); 468 if (targdata->cur_sb[targdata->level] == NULL) 469 err(1, "%s: Unable to allocate sbuf", __func__); 470 471 if (strcmp(name, "targ_port") == 0) { 472 int i = 0; 473 474 targdata->lun = -1; 475 targdata->id = -1; 476 free(targdata->target); 477 targdata->target = NULL; 478 while (attr[i]) { 479 if (strcmp(attr[i], "id") == 0) { 480 /* 481 * Well-formed XML always pairs keys with 482 * values in attr 483 */ 484 assert(attr[i + 1]); 485 targdata->id = atoi(attr[i + 1]); 486 } 487 i += 2; 488 } 489 490 } 491 } 492 493 static void 494 cctl_char_phandler(void *user_data, const XML_Char *str, int len) 495 { 496 struct cctl_portlist_data *targdata = user_data; 497 498 sbuf_bcat(targdata->cur_sb[targdata->level], str, len); 499 } 500 501 static void 502 cctl_end_pelement(void *user_data, const char *name) 503 { 504 struct cctl_portlist_data* targdata = user_data; 505 char *str; 506 507 if (targdata->cur_sb[targdata->level] == NULL) 508 errx(1, "%s: no valid sbuf at level %d (name %s)", __func__, 509 targdata->level, name); 510 511 if (sbuf_finish(targdata->cur_sb[targdata->level]) != 0) 512 err(1, "%s: sbuf_finish", __func__); 513 str = strdup(sbuf_data(targdata->cur_sb[targdata->level])); 514 if (str == NULL) 515 err(1, "%s can't allocate %zd bytes for string", __func__, 516 sbuf_len(targdata->cur_sb[targdata->level])); 517 518 sbuf_delete(targdata->cur_sb[targdata->level]); 519 targdata->cur_sb[targdata->level] = NULL; 520 targdata->level--; 521 522 if (strcmp(name, "target") == 0) { 523 free(targdata->target); 524 targdata->target = str; 525 } else if (strcmp(name, "targ_port") == 0) { 526 if (targdata->id >= 0 && targdata->target != NULL) { 527 if (targdata->id >= targdata->ntargets) { 528 /* 529 * This can happen for example if there are 530 * targets with no LUNs. 531 */ 532 targdata->ntargets = MAX(targdata->ntargets * 2, 533 targdata->id + 1); 534 size_t newsize = targdata->ntargets * 535 sizeof(char*); 536 targdata->targets = rallocx(targdata->targets, 537 newsize, MALLOCX_ZERO); 538 } 539 free(targdata->targets[targdata->id]); 540 targdata->targets[targdata->id] = targdata->target; 541 targdata->target = NULL; 542 } 543 free(str); 544 } else { 545 free(str); 546 } 547 } 548 549 static void 550 ctlstat_prometheus(int fd, struct ctlstat_context *ctx, bool ports) { 551 struct ctl_io_stats *stats = ctx->cur_stats; 552 struct ctl_lun_list list; 553 struct cctl_portlist_data targdata; 554 XML_Parser parser; 555 char *port_str = NULL; 556 int iotype, i, n, retval; 557 int port_len = 4096; 558 const char *collector; 559 560 bzero(&targdata, sizeof(targdata)); 561 targdata.ntargets = ctx->cur_items; 562 targdata.targets = calloc(targdata.ntargets, sizeof(char*)); 563 retry: 564 port_str = (char *)realloc(port_str, port_len); 565 bzero(&list, sizeof(list)); 566 list.alloc_len = port_len; 567 list.status = CTL_LUN_LIST_NONE; 568 list.lun_xml = port_str; 569 if (ioctl(fd, CTL_PORT_LIST, &list) == -1) 570 err(1, "%s: error issuing CTL_PORT_LIST ioctl", __func__); 571 if (list.status == CTL_LUN_LIST_ERROR) { 572 warnx("%s: error returned from CTL_PORT_LIST ioctl:\n%s", 573 __func__, list.error_str); 574 } else if (list.status == CTL_LUN_LIST_NEED_MORE_SPACE) { 575 port_len <<= 1; 576 goto retry; 577 } 578 579 parser = XML_ParserCreate(NULL); 580 if (parser == NULL) 581 err(1, "%s: Unable to create XML parser", __func__); 582 XML_SetUserData(parser, &targdata); 583 XML_SetElementHandler(parser, cctl_start_pelement, cctl_end_pelement); 584 XML_SetCharacterDataHandler(parser, cctl_char_phandler); 585 586 retval = XML_Parse(parser, port_str, strlen(port_str), 1); 587 if (retval != 1) { 588 errx(1, "%s: Unable to parse XML: Error %d", __func__, 589 XML_GetErrorCode(parser)); 590 } 591 XML_ParserFree(parser); 592 593 collector = ports ? "port" : "lun"; 594 595 printf("# HELP iscsi_%s_bytes Number of bytes\n" 596 "# TYPE iscsi_%s_bytes counter\n", collector, collector); 597 CTLSTAT_PROMETHEUS_LOOP(bytes, collector); 598 printf("# HELP iscsi_%s_dmas Number of DMA\n" 599 "# TYPE iscsi_%s_dmas counter\n", collector, collector); 600 CTLSTAT_PROMETHEUS_LOOP(dmas, collector); 601 printf("# HELP iscsi_%s_operations Number of operations\n" 602 "# TYPE iscsi_%s_operations counter\n", collector, collector); 603 CTLSTAT_PROMETHEUS_LOOP(operations, collector); 604 printf("# HELP iscsi_%s_time Cumulative operation time in us\n" 605 "# TYPE iscsi_%s_time counter\n", collector, collector); 606 CTLSTAT_PROMETHEUS_TIMELOOP(time, collector); 607 printf("# HELP iscsi_%s_dma_time Cumulative DMA time in us\n" 608 "# TYPE iscsi_%s_dma_time counter\n", collector, collector); 609 CTLSTAT_PROMETHEUS_TIMELOOP(dma_time, collector); 610 611 for (i = 0; i < targdata.ntargets; i++) 612 free(targdata.targets[i]); 613 free(targdata.target); 614 free(targdata.targets); 615 616 fflush(stdout); 617 } 618 619 static void 620 ctlstat_standard(struct ctlstat_context *ctx) { 621 long double etime; 622 uint64_t delta_jiffies, delta_idle; 623 long double cpu_percentage; 624 int i, j, n; 625 626 cpu_percentage = 0; 627 628 if (F_CPU(ctx) && (getcpu(&ctx->cur_cpu) != 0)) 629 errx(1, "error returned from getcpu()"); 630 631 etime = ctx->cur_time.tv_sec - ctx->prev_time.tv_sec + 632 (ctx->prev_time.tv_nsec - ctx->cur_time.tv_nsec) * 1e-9; 633 634 if (F_CPU(ctx)) { 635 ctx->prev_total_jiffies = ctx->cur_total_jiffies; 636 ctx->cur_total_jiffies = ctx->cur_cpu.user + 637 ctx->cur_cpu.nice + ctx->cur_cpu.system + 638 ctx->cur_cpu.intr + ctx->cur_cpu.idle; 639 delta_jiffies = ctx->cur_total_jiffies; 640 if (F_FIRST(ctx) == 0) 641 delta_jiffies -= ctx->prev_total_jiffies; 642 ctx->prev_idle = ctx->cur_idle; 643 ctx->cur_idle = ctx->cur_cpu.idle; 644 delta_idle = ctx->cur_idle - ctx->prev_idle; 645 646 cpu_percentage = delta_jiffies - delta_idle; 647 cpu_percentage /= delta_jiffies; 648 cpu_percentage *= 100; 649 } 650 651 if (F_HDR(ctx)) { 652 ctx->header_interval--; 653 if (ctx->header_interval <= 0) { 654 if (F_CPU(ctx)) 655 fprintf(stdout, " CPU"); 656 if (F_TOTALS(ctx)) { 657 fprintf(stdout, "%s Read %s" 658 " Write %s Total\n", 659 (F_TIMEVAL(ctx) != 0) ? " " : "", 660 (F_TIMEVAL(ctx) != 0) ? " " : "", 661 (F_TIMEVAL(ctx) != 0) ? " " : ""); 662 n = 3; 663 } else { 664 for (i = n = 0; i < min(ctl_stat_bits, 665 ctx->cur_items); i++) { 666 int item; 667 668 /* 669 * Obviously this won't work with 670 * LUN numbers greater than a signed 671 * integer. 672 */ 673 item = (int)ctx->cur_stats[i].item; 674 675 if (F_MASK(ctx) && 676 bit_test(ctx->item_mask, item) == 0) 677 continue; 678 fprintf(stdout, "%15.6s%d %s", 679 F_PORTS(ctx) ? "port" : "lun", item, 680 (F_TIMEVAL(ctx) != 0) ? " " : ""); 681 if (++n >= ctx->numdevs) 682 break; 683 } 684 fprintf(stdout, "\n"); 685 } 686 if (F_CPU(ctx)) 687 fprintf(stdout, " "); 688 for (i = 0; i < n; i++) 689 fprintf(stdout, "%s KB/t %s MB/s", 690 (F_TIMEVAL(ctx) != 0) ? " ms" : "", 691 (F_DMA(ctx) == 0) ? "tps" : "dps"); 692 fprintf(stdout, "\n"); 693 ctx->header_interval = 20; 694 } 695 } 696 697 if (F_CPU(ctx)) 698 fprintf(stdout, "%3.0Lf%%", cpu_percentage); 699 if (F_TOTALS(ctx) != 0) { 700 long double mbsec[3]; 701 long double kb_per_transfer[3]; 702 long double transfers_per_sec[3]; 703 long double ms_per_transfer[3]; 704 long double ms_per_dma[3]; 705 long double dmas_per_sec[3]; 706 707 for (i = 0; i < 3; i++) 708 ctx->prev_total_stats[i] = ctx->cur_total_stats[i]; 709 710 memset(&ctx->cur_total_stats, 0, sizeof(ctx->cur_total_stats)); 711 712 /* Use macros to make the next loop more readable. */ 713 #define ADD_STATS_BYTES(st, i, j) \ 714 ctx->cur_total_stats[st].bytes[j] += \ 715 ctx->cur_stats[i].bytes[j] 716 #define ADD_STATS_OPERATIONS(st, i, j) \ 717 ctx->cur_total_stats[st].operations[j] += \ 718 ctx->cur_stats[i].operations[j] 719 #define ADD_STATS_DMAS(st, i, j) \ 720 ctx->cur_total_stats[st].dmas[j] += \ 721 ctx->cur_stats[i].dmas[j] 722 #define ADD_STATS_TIME(st, i, j) \ 723 bintime_add(&ctx->cur_total_stats[st].time[j], \ 724 &ctx->cur_stats[i].time[j]) 725 #define ADD_STATS_DMA_TIME(st, i, j) \ 726 bintime_add(&ctx->cur_total_stats[st].dma_time[j], \ 727 &ctx->cur_stats[i].dma_time[j]) 728 729 for (i = 0; i < ctx->cur_items; i++) { 730 if (F_MASK(ctx) && bit_test(ctx->item_mask, 731 (int)ctx->cur_stats[i].item) == 0) 732 continue; 733 for (j = 0; j < CTL_STATS_NUM_TYPES; j++) { 734 ADD_STATS_BYTES(2, i, j); 735 ADD_STATS_OPERATIONS(2, i, j); 736 ADD_STATS_DMAS(2, i, j); 737 ADD_STATS_TIME(2, i, j); 738 ADD_STATS_DMA_TIME(2, i, j); 739 } 740 ADD_STATS_BYTES(0, i, CTL_STATS_READ); 741 ADD_STATS_OPERATIONS(0, i, CTL_STATS_READ); 742 ADD_STATS_DMAS(0, i, CTL_STATS_READ); 743 ADD_STATS_TIME(0, i, CTL_STATS_READ); 744 ADD_STATS_DMA_TIME(0, i, CTL_STATS_READ); 745 746 ADD_STATS_BYTES(1, i, CTL_STATS_WRITE); 747 ADD_STATS_OPERATIONS(1, i, CTL_STATS_WRITE); 748 ADD_STATS_DMAS(1, i, CTL_STATS_WRITE); 749 ADD_STATS_TIME(1, i, CTL_STATS_WRITE); 750 ADD_STATS_DMA_TIME(1, i, CTL_STATS_WRITE); 751 } 752 753 for (i = 0; i < 3; i++) { 754 compute_stats(&ctx->cur_total_stats[i], 755 F_FIRST(ctx) ? NULL : &ctx->prev_total_stats[i], 756 etime, &mbsec[i], &kb_per_transfer[i], 757 &transfers_per_sec[i], 758 &ms_per_transfer[i], &ms_per_dma[i], 759 &dmas_per_sec[i]); 760 if (F_DMA(ctx) != 0) 761 fprintf(stdout, " %5.1Lf", 762 ms_per_dma[i]); 763 else if (F_TIMEVAL(ctx) != 0) 764 fprintf(stdout, " %5.1Lf", 765 ms_per_transfer[i]); 766 fprintf(stdout, " %4.0Lf %5.0Lf %4.0Lf", 767 kb_per_transfer[i], 768 (F_DMA(ctx) == 0) ? transfers_per_sec[i] : 769 dmas_per_sec[i], mbsec[i]); 770 } 771 } else { 772 for (i = n = 0; i < min(ctl_stat_bits, ctx->cur_items); i++) { 773 long double mbsec, kb_per_transfer; 774 long double transfers_per_sec; 775 long double ms_per_transfer; 776 long double ms_per_dma; 777 long double dmas_per_sec; 778 779 if (F_MASK(ctx) && bit_test(ctx->item_mask, 780 (int)ctx->cur_stats[i].item) == 0) 781 continue; 782 for (j = 0; j < ctx->prev_items; j++) { 783 if (ctx->prev_stats[j].item == 784 ctx->cur_stats[i].item) 785 break; 786 } 787 if (j >= ctx->prev_items) 788 j = -1; 789 compute_stats(&ctx->cur_stats[i], 790 j >= 0 ? &ctx->prev_stats[j] : NULL, 791 etime, &mbsec, &kb_per_transfer, 792 &transfers_per_sec, &ms_per_transfer, 793 &ms_per_dma, &dmas_per_sec); 794 if (F_DMA(ctx)) 795 fprintf(stdout, " %5.1Lf", 796 ms_per_dma); 797 else if (F_TIMEVAL(ctx) != 0) 798 fprintf(stdout, " %5.1Lf", 799 ms_per_transfer); 800 fprintf(stdout, " %4.0Lf %5.0Lf %4.0Lf", 801 kb_per_transfer, (F_DMA(ctx) == 0) ? 802 transfers_per_sec : dmas_per_sec, mbsec); 803 if (++n >= ctx->numdevs) 804 break; 805 } 806 } 807 } 808 809 static void 810 get_and_print_stats(int fd, struct ctlstat_context *ctx, bool ports) 811 { 812 struct ctl_io_stats *tmp_stats; 813 int c; 814 815 tmp_stats = ctx->prev_stats; 816 ctx->prev_stats = ctx->cur_stats; 817 ctx->cur_stats = tmp_stats; 818 c = ctx->prev_alloc; 819 ctx->prev_alloc = ctx->cur_alloc; 820 ctx->cur_alloc = c; 821 c = ctx->prev_items; 822 ctx->prev_items = ctx->cur_items; 823 ctx->cur_items = c; 824 ctx->prev_time = ctx->cur_time; 825 ctx->prev_cpu = ctx->cur_cpu; 826 if (getstats(fd, &ctx->cur_alloc, &ctx->cur_items, 827 &ctx->cur_stats, &ctx->cur_time, &ctx->flags, ports) != 0) 828 errx(1, "error returned from getstats()"); 829 830 switch(ctx->mode) { 831 case CTLSTAT_MODE_STANDARD: 832 ctlstat_standard(ctx); 833 break; 834 case CTLSTAT_MODE_DUMP: 835 ctlstat_dump(ctx); 836 break; 837 case CTLSTAT_MODE_JSON: 838 ctlstat_json(ctx); 839 break; 840 case CTLSTAT_MODE_PROMETHEUS: 841 ctlstat_prometheus(fd, ctx, ports); 842 break; 843 default: 844 break; 845 } 846 } 847 848 int 849 main(int argc, char **argv) 850 { 851 int c; 852 int count, waittime; 853 int fd, retval; 854 size_t size; 855 struct ctlstat_context ctx; 856 857 /* default values */ 858 retval = 0; 859 waittime = 1; 860 count = -1; 861 memset(&ctx, 0, sizeof(ctx)); 862 ctx.numdevs = 3; 863 ctx.mode = CTLSTAT_MODE_STANDARD; 864 ctx.flags |= CTLSTAT_FLAG_CPU; 865 ctx.flags |= CTLSTAT_FLAG_FIRST_RUN; 866 ctx.flags |= CTLSTAT_FLAG_HEADER; 867 868 size = sizeof(ctl_stat_bits); 869 if (sysctlbyname("kern.cam.ctl.max_luns", &ctl_stat_bits, &size, NULL, 870 0) == -1) { 871 /* Backward compatibility for where the sysctl wasn't exposed */ 872 ctl_stat_bits = 1024; 873 } 874 ctx.item_mask = bit_alloc(ctl_stat_bits); 875 if (ctx.item_mask == NULL) 876 err(1, "bit_alloc() failed"); 877 878 while ((c = getopt(argc, argv, ctlstat_opts)) != -1) { 879 switch (c) { 880 case 'C': 881 ctx.flags &= ~CTLSTAT_FLAG_CPU; 882 break; 883 case 'c': 884 count = atoi(optarg); 885 break; 886 case 'd': 887 ctx.flags |= CTLSTAT_FLAG_DMA_TIME; 888 break; 889 case 'D': 890 ctx.mode = CTLSTAT_MODE_DUMP; 891 waittime = 30; 892 break; 893 case 'h': 894 ctx.flags &= ~CTLSTAT_FLAG_HEADER; 895 break; 896 case 'j': 897 ctx.mode = CTLSTAT_MODE_JSON; 898 waittime = 30; 899 break; 900 case 'l': { 901 int cur_lun; 902 903 cur_lun = atoi(optarg); 904 if (cur_lun > ctl_stat_bits) 905 errx(1, "Invalid LUN number %d", cur_lun); 906 907 if (!F_MASK(&ctx)) 908 ctx.numdevs = 1; 909 else 910 ctx.numdevs++; 911 bit_set(ctx.item_mask, cur_lun); 912 ctx.flags |= CTLSTAT_FLAG_MASK; 913 ctx.flags |= CTLSTAT_FLAG_LUNS; 914 break; 915 } 916 case 'n': 917 ctx.numdevs = atoi(optarg); 918 break; 919 case 'p': { 920 int cur_port; 921 922 cur_port = atoi(optarg); 923 if (cur_port > ctl_stat_bits) 924 errx(1, "Invalid port number %d", cur_port); 925 926 if (!F_MASK(&ctx)) 927 ctx.numdevs = 1; 928 else 929 ctx.numdevs++; 930 bit_set(ctx.item_mask, cur_port); 931 ctx.flags |= CTLSTAT_FLAG_MASK; 932 ctx.flags |= CTLSTAT_FLAG_PORTS; 933 break; 934 } 935 case 'P': 936 ctx.mode = CTLSTAT_MODE_PROMETHEUS; 937 break; 938 case 't': 939 ctx.flags |= CTLSTAT_FLAG_TOTALS; 940 break; 941 case 'w': 942 waittime = atoi(optarg); 943 break; 944 default: 945 retval = 1; 946 usage(retval); 947 exit(retval); 948 break; 949 } 950 } 951 952 if (F_LUNS(&ctx) && F_PORTS(&ctx)) 953 errx(1, "Options -p and -l are exclusive."); 954 955 if (ctx.mode == CTLSTAT_MODE_PROMETHEUS) { 956 if ((count != -1) || 957 (waittime != 1) || 958 (F_PORTS(&ctx)) || 959 /* NB: -P could be compatible with -t in the future */ 960 (ctx.flags & CTLSTAT_FLAG_TOTALS)) 961 { 962 errx(1, "Option -P is exclusive with -p, -c, -w, and -t"); 963 } 964 count = 1; 965 } 966 967 if (!F_LUNS(&ctx) && !F_PORTS(&ctx)) { 968 if (F_TOTALS(&ctx)) 969 ctx.flags |= CTLSTAT_FLAG_PORTS; 970 else 971 ctx.flags |= CTLSTAT_FLAG_LUNS; 972 } 973 974 if ((fd = open(CTL_DEFAULT_DEV, O_RDWR)) == -1) 975 err(1, "cannot open %s", CTL_DEFAULT_DEV); 976 977 if (ctx.mode == CTLSTAT_MODE_PROMETHEUS) { 978 /* 979 * NB: Some clients will print a warning if we don't set 980 * Content-Length, but they still work. And the data still 981 * gets into Prometheus. 982 */ 983 printf("HTTP/1.1 200 OK\r\n" 984 "Connection: close\r\n" 985 "Content-Type: text/plain; version=0.0.4\r\n" 986 "\r\n"); 987 } 988 989 for (;count != 0;) { 990 bool ports; 991 992 if (ctx.mode == CTLSTAT_MODE_PROMETHEUS) { 993 get_and_print_stats(fd, &ctx, false); 994 get_and_print_stats(fd, &ctx, true); 995 } else { 996 ports = ctx.flags & CTLSTAT_FLAG_PORTS; 997 get_and_print_stats(fd, &ctx, ports); 998 } 999 1000 fprintf(stdout, "\n"); 1001 fflush(stdout); 1002 ctx.flags &= ~CTLSTAT_FLAG_FIRST_RUN; 1003 if (count != 1) 1004 sleep(waittime); 1005 if (count > 0) 1006 count--; 1007 } 1008 1009 exit (retval); 1010 } 1011 1012 /* 1013 * vim: ts=8 1014 */ 1015