1 /*- 2 * Copyright (c) 2004, 2008, 2009 Silicon Graphics International Corp. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions, and the following disclaimer, 10 * without modification. 11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12 * substantially similar to the "NO WARRANTY" disclaimer below 13 * ("Disclaimer") and any redistribution must be conditioned upon 14 * including a substantially similar Disclaimer requirement for further 15 * binary redistribution. 16 * 17 * NO WARRANTY 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 26 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 27 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGES. 29 * 30 * $Id: //depot/users/kenm/FreeBSD-test2/usr.bin/ctlstat/ctlstat.c#4 $ 31 */ 32 /* 33 * CAM Target Layer statistics program 34 * 35 * Authors: Ken Merry <ken@FreeBSD.org>, Will Andrews <will@FreeBSD.org> 36 */ 37 38 #include <sys/cdefs.h> 39 __FBSDID("$FreeBSD$"); 40 41 #include <sys/ioctl.h> 42 #include <sys/types.h> 43 #include <sys/param.h> 44 #include <sys/time.h> 45 #include <sys/sysctl.h> 46 #include <sys/resource.h> 47 #include <sys/queue.h> 48 #include <sys/callout.h> 49 #include <stdint.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <unistd.h> 53 #include <fcntl.h> 54 #include <getopt.h> 55 #include <string.h> 56 #include <errno.h> 57 #include <err.h> 58 #include <ctype.h> 59 #include <bitstring.h> 60 #include <cam/scsi/scsi_all.h> 61 #include <cam/ctl/ctl.h> 62 #include <cam/ctl/ctl_io.h> 63 #include <cam/ctl/ctl_scsi_all.h> 64 #include <cam/ctl/ctl_util.h> 65 #include <cam/ctl/ctl_frontend_internal.h> 66 #include <cam/ctl/ctl_backend.h> 67 #include <cam/ctl/ctl_ioctl.h> 68 69 /* 70 * The default amount of space we allocate for LUN storage space. We 71 * dynamically allocate more if needed. 72 */ 73 #define CTL_STAT_NUM_LUNS 30 74 75 /* 76 * The default number of LUN selection bits we allocate. This is large 77 * because we don't currently increase it if the user specifies a LUN 78 * number of 1024 or larger. 79 */ 80 #define CTL_STAT_LUN_BITS 1024L 81 82 static const char *ctlstat_opts = "Cc:Ddhjl:n:tw:"; 83 static const char *ctlstat_usage = "Usage: ctlstat [-CDdjht] [-l lunnum]" 84 "[-c count] [-n numdevs] [-w wait]\n"; 85 86 struct ctl_cpu_stats { 87 uint64_t user; 88 uint64_t nice; 89 uint64_t system; 90 uint64_t intr; 91 uint64_t idle; 92 }; 93 94 typedef enum { 95 CTLSTAT_MODE_STANDARD, 96 CTLSTAT_MODE_DUMP, 97 CTLSTAT_MODE_JSON, 98 } ctlstat_mode_types; 99 100 #define CTLSTAT_FLAG_CPU (1 << 0) 101 #define CTLSTAT_FLAG_HEADER (1 << 1) 102 #define CTLSTAT_FLAG_FIRST_RUN (1 << 2) 103 #define CTLSTAT_FLAG_TOTALS (1 << 3) 104 #define CTLSTAT_FLAG_DMA_TIME (1 << 4) 105 #define CTLSTAT_FLAG_LUN_TIME_VALID (1 << 5) 106 #define F_CPU(ctx) ((ctx)->flags & CTLSTAT_FLAG_CPU) 107 #define F_HDR(ctx) ((ctx)->flags & CTLSTAT_FLAG_HEADER) 108 #define F_FIRST(ctx) ((ctx)->flags & CTLSTAT_FLAG_FIRST_RUN) 109 #define F_TOTALS(ctx) ((ctx)->flags & CTLSTAT_FLAG_TOTALS) 110 #define F_DMA(ctx) ((ctx)->flags & CTLSTAT_FLAG_DMA_TIME) 111 #define F_LUNVAL(ctx) ((ctx)->flags & CTLSTAT_FLAG_LUN_TIME_VALID) 112 113 struct ctlstat_context { 114 ctlstat_mode_types mode; 115 int flags; 116 struct ctl_lun_io_stats *cur_lun_stats, *prev_lun_stats, 117 *tmp_lun_stats; 118 struct ctl_lun_io_stats cur_total_stats[3], prev_total_stats[3]; 119 struct timespec cur_time, prev_time; 120 struct ctl_cpu_stats cur_cpu, prev_cpu; 121 uint64_t cur_total_jiffies, prev_total_jiffies; 122 uint64_t cur_idle, prev_idle; 123 bitstr_t bit_decl(lun_mask, CTL_STAT_LUN_BITS); 124 int num_luns; 125 int numdevs; 126 int header_interval; 127 }; 128 129 #ifndef min 130 #define min(x,y) (((x) < (y)) ? (x) : (y)) 131 #endif 132 133 static void usage(int error); 134 static int getstats(int fd, int *num_luns, struct ctl_lun_io_stats **xlun_stats, 135 struct timespec *cur_time, int *lun_time_valid); 136 static int getcpu(struct ctl_cpu_stats *cpu_stats); 137 static void compute_stats(struct ctl_lun_io_stats *cur_stats, 138 struct ctl_lun_io_stats *prev_stats, 139 long double etime, long double *mbsec, 140 long double *kb_per_transfer, 141 long double *transfers_per_second, 142 long double *ms_per_transfer, 143 long double *ms_per_dma, 144 long double *dmas_per_second); 145 146 static void 147 usage(int error) 148 { 149 fputs(ctlstat_usage, error ? stderr : stdout); 150 } 151 152 static int 153 getstats(int fd, int *num_luns, struct ctl_lun_io_stats **xlun_stats, 154 struct timespec *cur_time, int *flags) 155 { 156 struct ctl_lun_io_stats *lun_stats; 157 struct ctl_stats stats; 158 int more_space_count; 159 160 more_space_count = 0; 161 162 if (*num_luns == 0) 163 *num_luns = CTL_STAT_NUM_LUNS; 164 165 lun_stats = *xlun_stats; 166 retry: 167 168 if (lun_stats == NULL) { 169 lun_stats = (struct ctl_lun_io_stats *)malloc( 170 sizeof(*lun_stats) * *num_luns); 171 } 172 173 memset(&stats, 0, sizeof(stats)); 174 stats.alloc_len = *num_luns * sizeof(*lun_stats); 175 memset(lun_stats, 0, stats.alloc_len); 176 stats.lun_stats = lun_stats; 177 178 if (ioctl(fd, CTL_GETSTATS, &stats) == -1) 179 err(1, "error returned from CTL_GETSTATS ioctl"); 180 181 switch (stats.status) { 182 case CTL_SS_OK: 183 break; 184 case CTL_SS_ERROR: 185 err(1, "CTL_SS_ERROR returned from CTL_GETSTATS ioctl"); 186 break; 187 case CTL_SS_NEED_MORE_SPACE: 188 if (more_space_count > 0) { 189 errx(1, "CTL_GETSTATS returned NEED_MORE_SPACE again"); 190 } 191 *num_luns = stats.num_luns; 192 free(lun_stats); 193 lun_stats = NULL; 194 more_space_count++; 195 goto retry; 196 break; /* NOTREACHED */ 197 default: 198 errx(1, "unknown status %d returned from CTL_GETSTATS ioctl", 199 stats.status); 200 break; 201 } 202 203 *xlun_stats = lun_stats; 204 *num_luns = stats.num_luns; 205 cur_time->tv_sec = stats.timestamp.tv_sec; 206 cur_time->tv_nsec = stats.timestamp.tv_nsec; 207 if (stats.flags & CTL_STATS_FLAG_TIME_VALID) 208 *flags |= CTLSTAT_FLAG_LUN_TIME_VALID; 209 else 210 *flags &= ~CTLSTAT_FLAG_LUN_TIME_VALID; 211 212 return (0); 213 } 214 215 static int 216 getcpu(struct ctl_cpu_stats *cpu_stats) 217 { 218 long cp_time[CPUSTATES]; 219 size_t cplen; 220 221 cplen = sizeof(cp_time); 222 223 if (sysctlbyname("kern.cp_time", &cp_time, &cplen, NULL, 0) == -1) { 224 warn("sysctlbyname(kern.cp_time...) failed"); 225 return (1); 226 } 227 228 cpu_stats->user = cp_time[CP_USER]; 229 cpu_stats->nice = cp_time[CP_NICE]; 230 cpu_stats->system = cp_time[CP_SYS]; 231 cpu_stats->intr = cp_time[CP_INTR]; 232 cpu_stats->idle = cp_time[CP_IDLE]; 233 234 return (0); 235 } 236 237 static void 238 compute_stats(struct ctl_lun_io_stats *cur_stats, 239 struct ctl_lun_io_stats *prev_stats, long double etime, 240 long double *mbsec, long double *kb_per_transfer, 241 long double *transfers_per_second, long double *ms_per_transfer, 242 long double *ms_per_dma, long double *dmas_per_second) 243 { 244 uint64_t total_bytes = 0, total_operations = 0, total_dmas = 0; 245 uint32_t port; 246 struct bintime total_time_bt, total_dma_bt; 247 struct timespec total_time_ts, total_dma_ts; 248 int i; 249 250 bzero(&total_time_bt, sizeof(total_time_bt)); 251 bzero(&total_dma_bt, sizeof(total_dma_bt)); 252 bzero(&total_time_ts, sizeof(total_time_ts)); 253 bzero(&total_dma_ts, sizeof(total_dma_ts)); 254 for (port = 0; port < CTL_MAX_PORTS; port++) { 255 for (i = 0; i < CTL_STATS_NUM_TYPES; i++) { 256 total_bytes += cur_stats->ports[port].bytes[i]; 257 total_operations += 258 cur_stats->ports[port].operations[i]; 259 total_dmas += cur_stats->ports[port].num_dmas[i]; 260 bintime_add(&total_time_bt, 261 &cur_stats->ports[port].time[i]); 262 bintime_add(&total_dma_bt, 263 &cur_stats->ports[port].dma_time[i]); 264 if (prev_stats != NULL) { 265 total_bytes -= 266 prev_stats->ports[port].bytes[i]; 267 total_operations -= 268 prev_stats->ports[port].operations[i]; 269 total_dmas -= 270 prev_stats->ports[port].num_dmas[i]; 271 bintime_sub(&total_time_bt, 272 &prev_stats->ports[port].time[i]); 273 bintime_sub(&total_dma_bt, 274 &prev_stats->ports[port].dma_time[i]); 275 } 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(prefix, bt) \ 330 printf("%s %jd s %ju frac\n", prefix, (intmax_t)(bt).sec, \ 331 (uintmax_t)(bt).frac) 332 static const char *iotypes[] = {"NO IO", "READ", "WRITE"}; 333 334 static void 335 ctlstat_dump(struct ctlstat_context *ctx) { 336 int iotype, lun, port; 337 struct ctl_lun_io_stats *stats = ctx->cur_lun_stats; 338 339 for (lun = 0; lun < ctx->num_luns;lun++) { 340 printf("lun %d\n", lun); 341 for (port = 0; port < CTL_MAX_PORTS; port++) { 342 printf(" port %d\n", 343 stats[lun].ports[port].targ_port); 344 for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; 345 iotype++) { 346 printf(" io type %d (%s)\n", iotype, 347 iotypes[iotype]); 348 printf(" bytes %ju\n", (uintmax_t) 349 stats[lun].ports[port].bytes[iotype]); 350 printf(" operations %ju\n", (uintmax_t) 351 stats[lun].ports[port].operations[iotype]); 352 PRINT_BINTIME(" io time", 353 stats[lun].ports[port].time[iotype]); 354 printf(" num dmas %ju\n", (uintmax_t) 355 stats[lun].ports[port].num_dmas[iotype]); 356 PRINT_BINTIME(" dma time", 357 stats[lun].ports[port].dma_time[iotype]); 358 } 359 } 360 } 361 } 362 363 #define JSON_BINTIME(prefix, bt) \ 364 printf("\"%s\":{\"sec\":%jd,\"frac\":%ju},", \ 365 prefix, (intmax_t)(bt).sec, (uintmax_t)(bt).frac) 366 367 static void 368 ctlstat_json(struct ctlstat_context *ctx) { 369 int iotype, lun, port; 370 struct ctl_lun_io_stats *stats = ctx->cur_lun_stats; 371 372 printf("{\"luns\":["); 373 for (lun = 0; lun < ctx->num_luns; lun++) { 374 printf("{\"ports\":["); 375 for (port = 0; port < CTL_MAX_PORTS;port++) { 376 printf("{\"num\":%d,\"io\":[", 377 stats[lun].ports[port].targ_port); 378 for (iotype = 0; iotype < CTL_STATS_NUM_TYPES; 379 iotype++) { 380 printf("{\"type\":\"%s\",", iotypes[iotype]); 381 printf("\"bytes\":%ju,", (uintmax_t)stats[ 382 lun].ports[port].bytes[iotype]); 383 printf("\"operations\":%ju,", (uintmax_t)stats[ 384 lun].ports[port].operations[iotype]); 385 JSON_BINTIME("io time", 386 stats[lun].ports[port].time[iotype]); 387 JSON_BINTIME("dma time", 388 stats[lun].ports[port].dma_time[iotype]); 389 printf("\"num dmas\":%ju}", (uintmax_t) 390 stats[lun].ports[port].num_dmas[iotype]); 391 if (iotype < (CTL_STATS_NUM_TYPES - 1)) 392 printf(","); /* continue io array */ 393 } 394 printf("]}"); /* close port */ 395 if (port < (CTL_MAX_PORTS - 1)) 396 printf(","); /* continue port array */ 397 } 398 printf("]}"); /* close lun */ 399 if (lun < (ctx->num_luns - 1)) 400 printf(","); /* continue lun array */ 401 } 402 printf("]}"); /* close luns and toplevel */ 403 } 404 405 static void 406 ctlstat_standard(struct ctlstat_context *ctx) { 407 long double etime; 408 uint64_t delta_jiffies, delta_idle; 409 uint32_t port; 410 long double cpu_percentage; 411 int i; 412 int j; 413 414 cpu_percentage = 0; 415 416 if (F_CPU(ctx) && (getcpu(&ctx->cur_cpu) != 0)) 417 errx(1, "error returned from getcpu()"); 418 419 etime = ctx->cur_time.tv_sec - ctx->prev_time.tv_sec + 420 (ctx->prev_time.tv_nsec - ctx->cur_time.tv_nsec) * 1e-9; 421 422 if (F_CPU(ctx)) { 423 ctx->prev_total_jiffies = ctx->cur_total_jiffies; 424 ctx->cur_total_jiffies = ctx->cur_cpu.user + 425 ctx->cur_cpu.nice + ctx->cur_cpu.system + 426 ctx->cur_cpu.intr + ctx->cur_cpu.idle; 427 delta_jiffies = ctx->cur_total_jiffies; 428 if (F_FIRST(ctx) == 0) 429 delta_jiffies -= ctx->prev_total_jiffies; 430 ctx->prev_idle = ctx->cur_idle; 431 ctx->cur_idle = ctx->cur_cpu.idle; 432 delta_idle = ctx->cur_idle - ctx->prev_idle; 433 434 cpu_percentage = delta_jiffies - delta_idle; 435 cpu_percentage /= delta_jiffies; 436 cpu_percentage *= 100; 437 } 438 439 if (F_HDR(ctx)) { 440 ctx->header_interval--; 441 if (ctx->header_interval <= 0) { 442 int hdr_devs; 443 444 hdr_devs = 0; 445 446 if (F_TOTALS(ctx)) { 447 fprintf(stdout, "%s System Read %s" 448 "System Write %sSystem Total%s\n", 449 (F_LUNVAL(ctx) != 0) ? " " : "", 450 (F_LUNVAL(ctx) != 0) ? " " : "", 451 (F_LUNVAL(ctx) != 0) ? " " : "", 452 (F_CPU(ctx) == 0) ? " CPU" : ""); 453 hdr_devs = 3; 454 } else { 455 if (F_CPU(ctx)) 456 fprintf(stdout, " CPU "); 457 for (i = 0; i < min(CTL_STAT_LUN_BITS, 458 ctx->num_luns); i++) { 459 int lun; 460 461 /* 462 * Obviously this won't work with 463 * LUN numbers greater than a signed 464 * integer. 465 */ 466 lun = (int)ctx->cur_lun_stats[i 467 ].lun_number; 468 469 if (bit_test(ctx->lun_mask, lun) == 0) 470 continue; 471 fprintf(stdout, "%15.6s%d ", 472 "lun", lun); 473 hdr_devs++; 474 } 475 fprintf(stdout, "\n"); 476 } 477 for (i = 0; i < hdr_devs; i++) 478 fprintf(stdout, "%s %sKB/t %s MB/s ", 479 ((F_CPU(ctx) != 0) && (i == 0) && 480 (F_TOTALS(ctx) == 0)) ? " " : "", 481 (F_LUNVAL(ctx) != 0) ? " ms " : "", 482 (F_DMA(ctx) == 0) ? "tps" : "dps"); 483 fprintf(stdout, "\n"); 484 ctx->header_interval = 20; 485 } 486 } 487 488 if (F_TOTALS(ctx) != 0) { 489 long double mbsec[3]; 490 long double kb_per_transfer[3]; 491 long double transfers_per_sec[3]; 492 long double ms_per_transfer[3]; 493 long double ms_per_dma[3]; 494 long double dmas_per_sec[3]; 495 496 for (i = 0; i < 3; i++) 497 ctx->prev_total_stats[i] = ctx->cur_total_stats[i]; 498 499 memset(&ctx->cur_total_stats, 0, sizeof(ctx->cur_total_stats)); 500 501 /* Use macros to make the next loop more readable. */ 502 #define ADD_STATS_BYTES(st, p, i, j) \ 503 ctx->cur_total_stats[st].ports[p].bytes[j] += \ 504 ctx->cur_lun_stats[i].ports[p].bytes[j] 505 #define ADD_STATS_OPERATIONS(st, p, i, j) \ 506 ctx->cur_total_stats[st].ports[p].operations[j] += \ 507 ctx->cur_lun_stats[i].ports[p].operations[j] 508 #define ADD_STATS_NUM_DMAS(st, p, i, j) \ 509 ctx->cur_total_stats[st].ports[p].num_dmas[j] += \ 510 ctx->cur_lun_stats[i].ports[p].num_dmas[j] 511 #define ADD_STATS_TIME(st, p, i, j) \ 512 bintime_add(&ctx->cur_total_stats[st].ports[p].time[j], \ 513 &ctx->cur_lun_stats[i].ports[p].time[j]) 514 #define ADD_STATS_DMA_TIME(st, p, i, j) \ 515 bintime_add(&ctx->cur_total_stats[st].ports[p].dma_time[j], \ 516 &ctx->cur_lun_stats[i].ports[p].dma_time[j]) 517 518 for (i = 0; i < ctx->num_luns; i++) { 519 for (port = 0; port < CTL_MAX_PORTS; port++) { 520 for (j = 0; j < CTL_STATS_NUM_TYPES; j++) { 521 ADD_STATS_BYTES(2, port, i, j); 522 ADD_STATS_OPERATIONS(2, port, i, j); 523 ADD_STATS_NUM_DMAS(2, port, i, j); 524 ADD_STATS_TIME(2, port, i, j); 525 ADD_STATS_DMA_TIME(2, port, i, j); 526 } 527 ADD_STATS_BYTES(0, port, i, CTL_STATS_READ); 528 ADD_STATS_OPERATIONS(0, port, i, 529 CTL_STATS_READ); 530 ADD_STATS_NUM_DMAS(0, port, i, CTL_STATS_READ); 531 ADD_STATS_TIME(0, port, i, CTL_STATS_READ); 532 ADD_STATS_DMA_TIME(0, port, i, CTL_STATS_READ); 533 534 ADD_STATS_BYTES(1, port, i, CTL_STATS_WRITE); 535 ADD_STATS_OPERATIONS(1, port, i, 536 CTL_STATS_WRITE); 537 ADD_STATS_NUM_DMAS(1, port, i, CTL_STATS_WRITE); 538 ADD_STATS_TIME(1, port, i, CTL_STATS_WRITE); 539 ADD_STATS_DMA_TIME(1, port, i, CTL_STATS_WRITE); 540 } 541 } 542 543 for (i = 0; i < 3; i++) { 544 compute_stats(&ctx->cur_total_stats[i], 545 F_FIRST(ctx) ? NULL : &ctx->prev_total_stats[i], 546 etime, &mbsec[i], &kb_per_transfer[i], 547 &transfers_per_sec[i], 548 &ms_per_transfer[i], &ms_per_dma[i], 549 &dmas_per_sec[i]); 550 if (F_DMA(ctx) != 0) 551 fprintf(stdout, " %2.2Lf", 552 ms_per_dma[i]); 553 else if (F_LUNVAL(ctx) != 0) 554 fprintf(stdout, " %2.2Lf", 555 ms_per_transfer[i]); 556 fprintf(stdout, " %5.2Lf %3.0Lf %5.2Lf ", 557 kb_per_transfer[i], 558 (F_DMA(ctx) == 0) ? transfers_per_sec[i] : 559 dmas_per_sec[i], mbsec[i]); 560 } 561 if (F_CPU(ctx)) 562 fprintf(stdout, " %5.1Lf%%", cpu_percentage); 563 } else { 564 if (F_CPU(ctx)) 565 fprintf(stdout, "%5.1Lf%% ", cpu_percentage); 566 567 for (i = 0; i < min(CTL_STAT_LUN_BITS, ctx->num_luns); i++) { 568 long double mbsec, kb_per_transfer; 569 long double transfers_per_sec; 570 long double ms_per_transfer; 571 long double ms_per_dma; 572 long double dmas_per_sec; 573 574 if (bit_test(ctx->lun_mask, 575 (int)ctx->cur_lun_stats[i].lun_number) == 0) 576 continue; 577 compute_stats(&ctx->cur_lun_stats[i], F_FIRST(ctx) ? 578 NULL : &ctx->prev_lun_stats[i], etime, 579 &mbsec, &kb_per_transfer, 580 &transfers_per_sec, &ms_per_transfer, 581 &ms_per_dma, &dmas_per_sec); 582 if (F_DMA(ctx)) 583 fprintf(stdout, " %2.2Lf", 584 ms_per_dma); 585 else if (F_LUNVAL(ctx) != 0) 586 fprintf(stdout, " %2.2Lf", 587 ms_per_transfer); 588 fprintf(stdout, " %5.2Lf %3.0Lf %5.2Lf ", 589 kb_per_transfer, (F_DMA(ctx) == 0) ? 590 transfers_per_sec : dmas_per_sec, mbsec); 591 } 592 } 593 } 594 595 int 596 main(int argc, char **argv) 597 { 598 int c; 599 int count, waittime; 600 int set_lun; 601 int fd, retval; 602 struct ctlstat_context ctx; 603 604 /* default values */ 605 retval = 0; 606 waittime = 1; 607 count = -1; 608 memset(&ctx, 0, sizeof(ctx)); 609 ctx.numdevs = 3; 610 ctx.mode = CTLSTAT_MODE_STANDARD; 611 ctx.flags |= CTLSTAT_FLAG_CPU; 612 ctx.flags |= CTLSTAT_FLAG_FIRST_RUN; 613 ctx.flags |= CTLSTAT_FLAG_HEADER; 614 615 while ((c = getopt(argc, argv, ctlstat_opts)) != -1) { 616 switch (c) { 617 case 'C': 618 ctx.flags &= ~CTLSTAT_FLAG_CPU; 619 break; 620 case 'c': 621 count = atoi(optarg); 622 break; 623 case 'd': 624 ctx.flags |= CTLSTAT_FLAG_DMA_TIME; 625 break; 626 case 'D': 627 ctx.mode = CTLSTAT_MODE_DUMP; 628 waittime = 30; 629 break; 630 case 'h': 631 ctx.flags &= ~CTLSTAT_FLAG_HEADER; 632 break; 633 case 'j': 634 ctx.mode = CTLSTAT_MODE_JSON; 635 waittime = 30; 636 break; 637 case 'l': { 638 int cur_lun; 639 640 cur_lun = atoi(optarg); 641 if (cur_lun > CTL_STAT_LUN_BITS) 642 errx(1, "Invalid LUN number %d", cur_lun); 643 644 bit_ffs(ctx.lun_mask, CTL_STAT_LUN_BITS, &set_lun); 645 if (set_lun == -1) 646 ctx.numdevs = 1; 647 else 648 ctx.numdevs++; 649 bit_set(ctx.lun_mask, cur_lun); 650 break; 651 } 652 case 'n': 653 ctx.numdevs = atoi(optarg); 654 break; 655 case 't': 656 ctx.flags |= CTLSTAT_FLAG_TOTALS; 657 ctx.numdevs = 3; 658 break; 659 case 'w': 660 waittime = atoi(optarg); 661 break; 662 default: 663 retval = 1; 664 usage(retval); 665 exit(retval); 666 break; 667 } 668 } 669 670 bit_ffs(ctx.lun_mask, CTL_STAT_LUN_BITS, &set_lun); 671 672 if ((F_TOTALS(&ctx)) 673 && (set_lun != -1)) { 674 errx(1, "Total Mode (-t) is incompatible with individual " 675 "LUN mode (-l)"); 676 } else if (set_lun == -1) { 677 /* 678 * Note that this just selects the first N LUNs to display, 679 * but at this point we have no knoweledge of which LUN 680 * numbers actually exist. So we may select LUNs that 681 * aren't there. 682 */ 683 bit_nset(ctx.lun_mask, 0, min(ctx.numdevs - 1, 684 CTL_STAT_LUN_BITS - 1)); 685 } 686 687 if ((fd = open(CTL_DEFAULT_DEV, O_RDWR)) == -1) 688 err(1, "cannot open %s", CTL_DEFAULT_DEV); 689 690 for (;count != 0;) { 691 ctx.tmp_lun_stats = ctx.prev_lun_stats; 692 ctx.prev_lun_stats = ctx.cur_lun_stats; 693 ctx.cur_lun_stats = ctx.tmp_lun_stats; 694 ctx.prev_time = ctx.cur_time; 695 ctx.prev_cpu = ctx.cur_cpu; 696 if (getstats(fd, &ctx.num_luns, &ctx.cur_lun_stats, 697 &ctx.cur_time, &ctx.flags) != 0) 698 errx(1, "error returned from getstats()"); 699 700 switch(ctx.mode) { 701 case CTLSTAT_MODE_STANDARD: 702 ctlstat_standard(&ctx); 703 break; 704 case CTLSTAT_MODE_DUMP: 705 ctlstat_dump(&ctx); 706 break; 707 case CTLSTAT_MODE_JSON: 708 ctlstat_json(&ctx); 709 break; 710 default: 711 break; 712 } 713 714 fprintf(stdout, "\n"); 715 ctx.flags &= ~CTLSTAT_FLAG_FIRST_RUN; 716 if (count != 1) 717 sleep(waittime); 718 if (count > 0) 719 count--; 720 } 721 722 exit (retval); 723 } 724 725 /* 726 * vim: ts=8 727 */ 728