1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <string.h> 29 #include <unistd.h> 30 #include <errno.h> 31 #include <inttypes.h> 32 33 #include <kstat.h> 34 35 #include <sys/nsctl/nsctl.h> 36 #include <sys/nsctl/sd_bcache.h> 37 38 #include "sdbc_stats.h" 39 40 #include "dsstat.h" 41 #include "common.h" 42 #include "report.h" 43 44 static sdbcstat_t *sdbc_top; 45 kstat_t *sdbc_global = NULL; 46 47 void sdbc_header(); 48 int sdbc_value_check(sdbcstat_t *); 49 int sdbc_validate(kstat_t *); 50 uint32_t sdbc_getdelta(sdbcstat_t *, char *); 51 52 void sdbc_addstat(sdbcstat_t *); 53 sdbcstat_t *sdbc_delstat(sdbcstat_t *); 54 void center(int, char *); 55 56 /* 57 * sdbc_discover() - looks for new statistics to be monitored. 58 * Verifies that any statistics found are now already being 59 * monitored. 60 * 61 */ 62 int 63 sdbc_discover(kstat_ctl_t *kc) 64 { 65 static int validated = 0; 66 67 kstat_t *ksp; 68 69 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) { 70 int kinst; 71 char kname[KSTAT_STRLEN + 1]; 72 sdbcstat_t *cur; 73 sdbcstat_t *sdbcstat = NULL; 74 kstat_t *io_ksp; 75 76 if (strcmp(ksp->ks_module, SDBC_KSTAT_MODULE) != 0 || 77 strncmp(ksp->ks_name, SDBC_KSTAT_CDSTATS, 2) != 0) 78 continue; 79 80 if (kstat_read(kc, ksp, NULL) == -1) 81 continue; 82 83 /* 84 * Validate kstat structure 85 */ 86 if (! validated) { 87 if (sdbc_validate(ksp)) 88 return (EINVAL); 89 90 validated++; 91 } 92 93 /* 94 * Duplicate check 95 */ 96 for (cur = sdbc_top; cur; cur = cur->next) { 97 char *cur_vname, *tst_vname; 98 99 cur_vname = kstat_value(cur->pre_set, 100 SDBC_CDKSTAT_VOL_NAME); 101 102 tst_vname = kstat_value(ksp, 103 SDBC_CDKSTAT_VOL_NAME); 104 105 if (strncmp(cur_vname, tst_vname, NAMED_LEN) == 0) 106 goto next; 107 } 108 109 /* 110 * Initialize new record 111 */ 112 sdbcstat = (sdbcstat_t *)calloc(1, sizeof (sdbcstat_t)); 113 114 kinst = ksp->ks_instance; 115 116 /* 117 * Set kstat 118 */ 119 sdbcstat->pre_set = kstat_retrieve(kc, ksp); 120 121 if (sdbcstat->pre_set == NULL) 122 goto next; 123 124 sdbcstat->collected |= GOT_SET_KSTAT; 125 126 /* 127 * I/O kstat 128 */ 129 (void) sprintf(kname, "%s%d", SDBC_IOKSTAT_CDSTATS, kinst); 130 131 io_ksp = kstat_lookup(kc, SDBC_KSTAT_MODULE, kinst, kname); 132 sdbcstat->pre_io = kstat_retrieve(kc, io_ksp); 133 134 if (sdbcstat->pre_io == NULL) 135 goto next; 136 137 sdbcstat->collected |= GOT_IO_KSTAT; 138 139 next: 140 /* 141 * Check if we got a complete set of stats 142 */ 143 if (sdbcstat == NULL) 144 continue; 145 146 if (SDBC_COMPLETE(sdbcstat->collected)) { 147 (void) sdbc_delstat(sdbcstat); 148 continue; 149 } 150 151 sdbc_addstat(sdbcstat); 152 } 153 154 if (sdbc_top == NULL) 155 return (EAGAIN); 156 157 return (0); 158 } 159 160 /* 161 * sdbc_update() - updates all of the statistics currently being monitored. 162 * 163 */ 164 int 165 sdbc_update(kstat_ctl_t *kc) 166 { 167 kstat_t *ksp; 168 sdbcstat_t *cur; 169 170 /* Update global kstat information */ 171 ksp = kstat_lookup(kc, SDBC_KSTAT_MODULE, -1, SDBC_KSTAT_GSTATS); 172 173 if (ksp == NULL) 174 return (EAGAIN); 175 176 if (sdbc_global) 177 kstat_free(sdbc_global); 178 179 sdbc_global = kstat_retrieve(kc, ksp); 180 181 for (cur = sdbc_top; cur != NULL; cur = cur->next) { 182 int kinst; 183 char *kname, *cname, *pname; 184 185 kstat_t *set_ksp, *io_ksp; 186 187 cur->collected = 0; 188 189 /* 190 * Age off old stats 191 */ 192 if (cur->cur_set != NULL) { 193 kstat_free(cur->pre_set); 194 kstat_free(cur->pre_io); 195 196 cur->pre_set = cur->cur_set; 197 cur->pre_io = cur->cur_io; 198 } 199 200 /* 201 * Update set kstat 202 */ 203 kinst = cur->pre_set->ks_instance; 204 kname = cur->pre_set->ks_name; 205 206 set_ksp = kstat_lookup(kc, SDBC_KSTAT_MODULE, kinst, kname); 207 208 if ((cur->cur_set = kstat_retrieve(kc, set_ksp)) == NULL) 209 continue; 210 211 cur->collected |= GOT_SET_KSTAT; 212 213 /* 214 * Validate set 215 */ 216 pname = kstat_value(cur->pre_set, SDBC_CDKSTAT_VOL_NAME); 217 cname = kstat_value(cur->cur_set, SDBC_CDKSTAT_VOL_NAME); 218 219 if (strncmp(pname, cname, NAMED_LEN) != 0) 220 continue; 221 222 /* 223 * Update I/O kstat 224 */ 225 kinst = cur->pre_io->ks_instance; 226 kname = cur->pre_io->ks_name; 227 228 io_ksp = kstat_lookup(kc, SDBC_KSTAT_MODULE, kinst, kname); 229 230 if ((cur->cur_io = kstat_retrieve(kc, io_ksp)) == NULL) 231 continue; 232 233 cur->collected |= GOT_IO_KSTAT; 234 } 235 236 return (0); 237 } 238 239 /* 240 * sdbc_report() - outputs statistics for the statistics currently being 241 * monitored. Deletes statistics for volumes that have been disabled. 242 * 243 */ 244 int 245 sdbc_report() 246 { 247 vslist_t *vslist = vs_top; 248 sdbcstat_t *cur, *pre = NULL; 249 250 if (sdbc_top == NULL) 251 return (0); 252 253 for (cur = sdbc_top; cur != NULL; ) { /* CSTYLED */ 254 static uint32_t linesout = 0; 255 uint32_t *offline; 256 257 char volname[NAMED_LEN + 1]; 258 char rmode[STAT_HDR_SIZE]; 259 char wmode[STAT_HDR_SIZE]; 260 261 /* Parse volume name */ 262 (void) strncpy(volname, kstat_value(cur->pre_set, 263 SDBC_CDKSTAT_VOL_NAME), NAMED_LEN); 264 volname[NAMED_LEN] = '\0'; 265 266 /* Check to see if the user specified this volume */ 267 for (vslist = vs_top; vslist != NULL; vslist = vslist->next) 268 if (strcmp(volname, vslist->volname) == 0) 269 break; 270 271 if (vs_top != NULL && vslist == NULL) 272 goto next; 273 274 /* Check if volume is offline and zflag applies */ 275 if (zflag && sdbc_value_check(cur) == 0) 276 goto next; 277 278 /* Output volume name */ 279 sdbc_header(); 280 281 (void) printf(DATA_C16, volname); 282 283 if (SDBC_COMPLETE(cur->collected)) { 284 sdbcstat_t *next = sdbc_delstat(cur); 285 286 if (! pre) 287 cur = sdbc_top = next; 288 else 289 cur = pre->next = next; 290 291 (void) printf(" <<volume disabled>>\n"); 292 continue; 293 } 294 295 offline = kstat_value(cur->cur_set, SDBC_CDKSTAT_FAILED); 296 if (*offline) { 297 (void) printf(" <<volume offline>>\n"); 298 linesout++; 299 goto next; 300 } 301 302 /* Type/status flags */ 303 if (dflags & FLAGS) { 304 305 uint32_t *dhint, *nhint; 306 uint32_t hints; 307 308 dhint = kstat_value(cur->cur_set, SDBC_CDKSTAT_CDHINTS); 309 nhint = kstat_value(sdbc_global, SDBC_GKSTAT_NODEHINTS); 310 311 if (! nhint) 312 return (EINVAL); 313 314 hints = *nhint; 315 hints &= (NSC_FORCED_WRTHRU | NSC_NO_FORCED_WRTHRU | 316 NSC_NOCACHE); 317 hints |= *dhint; 318 319 if (hints & NSC_NOCACHE) 320 (void) strcpy(rmode, "D"); 321 else 322 (void) strcpy(rmode, "C"); 323 324 if ((hints & NSC_FORCED_WRTHRU) || (hints & NSC_WRTHRU)) 325 (void) strcpy(wmode, "D"); 326 else 327 (void) strcpy(wmode, "C"); 328 329 (void) printf(DATA_C2, rmode); 330 (void) printf(DATA_C2, wmode); 331 } 332 333 /* Output set information */ 334 cd_report(cur); 335 336 next: 337 pre = cur; 338 cur = cur->next; 339 } 340 341 return (0); 342 } 343 344 /* 345 * sdbc_header() - outputs an appropriate header by referencing the 346 * global variables dflsgs 347 * 348 */ 349 void 350 sdbc_header() 351 { 352 int rcount = 0; 353 354 if (hflags == HEADERS_EXL) 355 if ((linesout % DISPLAY_LINES) != 0) 356 return; 357 358 if (hflags == HEADERS_BOR) 359 if (linesout != 0) 360 return; 361 362 if (hflags & HEADERS_ATT) 363 if (hflags & HEADERS_OUT) 364 return; 365 else 366 hflags |= HEADERS_OUT; 367 368 if (linesout) 369 (void) printf("\n"); 370 371 /* first line header */ 372 if (! (dflags & SUMMARY) && dflags != FLAGS) { 373 374 (void) printf(VOL_HDR_FMT, " "); 375 376 if (dflags & FLAGS) { 377 (void) printf(STAT_HDR_FMT, " "); 378 (void) printf(STAT_HDR_FMT, " "); 379 } 380 381 if (dflags & READ) { 382 int size; 383 384 size = KPS_HDR_SIZE * 2 + HIT_HDR_SIZE; 385 center(size, "- read -"); 386 rcount++; 387 } 388 389 if (dflags & WRITE) { 390 int size; 391 392 size = KPS_HDR_SIZE * 2 + HIT_HDR_SIZE; 393 center(size, "- write -"); 394 rcount++; 395 } 396 397 if (dflags != FLAGS) 398 (void) printf("\n"); 399 } 400 401 /* second line header */ 402 (void) printf(VOL_HDR_FMT, "volume"); 403 404 if (dflags & FLAGS) { 405 (void) printf(STAT_HDR_FMT, "rd"); 406 (void) printf(STAT_HDR_FMT, "wr"); 407 } 408 409 if (dflags & SUMMARY) { 410 (void) printf(KPS_HDR_FMT, "ckps"); 411 (void) printf(KPS_HDR_FMT, "dkps"); 412 (void) printf(HIT_HDR_FMT, HIT_HDR_TXT); 413 414 goto out; 415 } 416 417 if (dflags & READ) { 418 (void) printf(KPS_HDR_FMT, "ckps"); 419 (void) printf(KPS_HDR_FMT, "dkps"); 420 (void) printf(HIT_HDR_FMT, RHIT_HDR_TXT); 421 } 422 423 if (dflags & WRITE) { 424 (void) printf(KPS_HDR_FMT, "ckps"); 425 (void) printf(KPS_HDR_FMT, "dkps"); 426 (void) printf(HIT_HDR_FMT, WHIT_HDR_TXT); 427 } 428 429 if (dflags & DESTAGED) 430 (void) printf(KPS_HDR_FMT, "dstg"); 431 432 if (dflags & WRCANCEL) 433 (void) printf(KPS_HDR_FMT, "cwrl"); 434 435 out: 436 (void) printf("\n"); 437 } 438 439 /* 440 * sdbc_getstat() - find cache stat by name matching 441 * 442 * paraemters 443 * char *vn - the volume name to match against 444 * returns 445 * sdbcstat_t * - the matching strcture, NULL if not found 446 */ 447 sdbcstat_t * 448 sdbc_getstat(char *vn) 449 { 450 sdbcstat_t *cur, *pre = NULL; 451 452 for (cur = sdbc_top; cur; ) { /* CSTYLED */ 453 char *volname = 454 kstat_value(cur->pre_set, SDBC_CDKSTAT_VOL_NAME); 455 456 if (SDBC_COMPLETE(cur->collected)) { 457 sdbcstat_t *next = sdbc_delstat(cur); 458 459 if (! pre) 460 cur = sdbc_top = next; 461 else 462 cur = pre->next = next; 463 464 continue; 465 } 466 467 if (strncmp(volname, vn, NAMED_LEN) == 0) 468 return (cur); 469 470 pre = cur; 471 cur = cur->next; 472 } 473 474 return (NULL); 475 } 476 477 /* 478 * sdbc_addstat() - adds a fully populated sdbcstat_t structure 479 * to the linked list of currently monitored kstats. The structure 480 * will be added in alphabetical order, using the volume name as the 481 * key. 482 * 483 * parameters 484 * sdbcstat_t *sdbcstat - to be added to the list. 485 * 486 */ 487 void 488 sdbc_addstat(sdbcstat_t *sdbcstat) 489 { 490 sdbcstat_t *cur; 491 492 if (sdbc_top == NULL) { 493 sdbc_top = sdbcstat; 494 return; 495 } 496 497 for (cur = sdbc_top; cur != NULL; cur = cur->next) { 498 char *cur_vname, *nxt_vname, *tst_vname; 499 500 cur_vname = kstat_value(cur->pre_set, 501 SDBC_CDKSTAT_VOL_NAME); 502 tst_vname = kstat_value(sdbcstat->pre_set, 503 SDBC_CDKSTAT_VOL_NAME); 504 505 if (strncmp(cur_vname, tst_vname, NAMED_LEN) > 0) { 506 if (cur == sdbc_top) 507 sdbc_top = sdbcstat; 508 509 sdbcstat->next = cur; 510 511 return; 512 } 513 514 /* 515 * If we get to the last item in the list, then just 516 * add this one to the end 517 */ 518 if (cur->next == NULL) { 519 cur->next = sdbcstat; 520 return; 521 } 522 523 nxt_vname = kstat_value(cur->next->pre_set, 524 SDBC_CDKSTAT_VOL_NAME); 525 526 if (strncmp(nxt_vname, tst_vname, NAMED_LEN) > 0) { 527 sdbcstat->next = cur->next; 528 cur->next = sdbcstat; 529 return; 530 } 531 } 532 } 533 534 /* 535 * sdbc_delstat() - deallocate memory for the structure being 536 * passed in. 537 * 538 * parameters 539 * sdbcstat_t *sdbcstat - structure to be deallocated 540 * 541 * returns 542 * sdbcstat_t * - pointer to the "next" structures in the 543 * linked list. May be NULL if we are removing the last 544 * structure in the linked list. 545 */ 546 sdbcstat_t * 547 sdbc_delstat(sdbcstat_t *sdbcstat) 548 { 549 550 sdbcstat_t *next = sdbcstat->next; 551 552 kstat_free(sdbcstat->pre_set); 553 kstat_free(sdbcstat->pre_io); 554 kstat_free(sdbcstat->cur_set); 555 kstat_free(sdbcstat->cur_io); 556 557 free(sdbcstat); 558 sdbcstat = NULL; 559 560 return (next); 561 } 562 563 /* 564 * sdbc_value_check() - Checks for activity, supports -z switch 565 * 566 * parameters 567 * sdbcstat_t *sdbcstat - structure to be checked 568 * 569 * returns 570 * 1 - activity 571 * 0 - no activity 572 */ 573 int 574 sdbc_value_check(sdbcstat_t *sdbcstat) 575 { 576 if (SDBC_COMPLETE(sdbcstat->collected)) 577 return (1); 578 579 if (sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_CACHE_READ) != 0) 580 return (1); 581 582 if (sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DISK_READ) != 0) 583 return (1); 584 585 if (sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_CACHE_WRITE) != 0) 586 return (1); 587 588 if (sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DISK_WRITE) != 0) 589 return (1); 590 591 if (sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_WRCANCELNS) != 0) 592 return (1); 593 594 if (io_value_check(sdbcstat->pre_io->ks_data, 595 sdbcstat->cur_io->ks_data) != 0) 596 return (1); 597 598 return (0); 599 } 600 601 /* 602 * sdbc_validate() - validates the structure of the kstats by attempting to 603 * lookup fields used by this module 604 * 605 * parameters 606 * kstat_t *ksp - kstat to be examined 607 * 608 * returns 609 * 1 - one or more fields missing 610 * 0 - all fields present 611 */ 612 int 613 sdbc_validate(kstat_t *ksp) 614 { 615 if (! kstat_value(ksp, SDBC_CDKSTAT_VOL_NAME) || 616 ! kstat_value(ksp, SDBC_CDKSTAT_FAILED) || 617 ! kstat_value(ksp, SDBC_CDKSTAT_CDHINTS) || 618 ! kstat_value(ksp, SDBC_CDKSTAT_CACHE_READ) || 619 ! kstat_value(ksp, SDBC_CDKSTAT_DISK_READ) || 620 ! kstat_value(ksp, SDBC_CDKSTAT_CACHE_WRITE) || 621 ! kstat_value(ksp, SDBC_CDKSTAT_DISK_WRITE) || 622 ! kstat_value(ksp, SDBC_CDKSTAT_DESTAGED) || 623 ! kstat_value(ksp, SDBC_CDKSTAT_WRCANCELNS)) 624 return (1); 625 626 return (0); 627 } 628 629 /* 630 * sdbc_getvalues() - populates a values structure with data obtained from the 631 * kstat 632 * 633 * parameters 634 * sdbcstat_t *sdbcstat - pointer to the structure containing the kstats 635 * sdbcvals_t *vals - pointer to the structure that will receive the values 636 * int flags - flags that describe adjustments made to the values 637 * 638 * returns 639 * 1 - failure 640 * 0 - success 641 */ 642 int 643 sdbc_getvalues(sdbcstat_t *sdbcstat, sdbcvals_t *vals, int flags) 644 { 645 int divisor = 0; 646 int factors; 647 uint64_t hr_etime; 648 double etime; 649 650 kstat_io_t *cur; 651 kstat_io_t *pre; 652 653 if (sdbcstat == NULL) 654 return (1); 655 656 cur = sdbcstat->cur_io->ks_data; 657 pre = sdbcstat->pre_io->ks_data; 658 659 hr_etime = hrtime_delta(pre->rlastupdate, cur->rlastupdate); 660 etime = hr_etime / (double)NANOSEC; 661 662 /* read data */ 663 vals->cache_read = 664 FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_CACHE_READ)); 665 vals->disk_read = 666 FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DISK_READ)); 667 668 669 vals->total_reads = vals->cache_read + vals->disk_read; 670 671 if (vals->cache_read == 0) 672 vals->read_hit = 0.0; 673 else 674 vals->read_hit = 675 ((float)vals->cache_read / vals->total_reads) * 100.0; 676 677 /* write data */ 678 vals->cache_write = 679 FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_CACHE_WRITE)); 680 vals->disk_write = 681 FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DISK_WRITE)); 682 683 vals->total_writes = vals->cache_write + vals->disk_write; 684 685 vals->destaged = 686 FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DESTAGED)); 687 688 if (vals->cache_write == 0) 689 vals->write_hit = 0.0; 690 else 691 vals->write_hit = ((float)vals->cache_write / 692 (vals->total_writes - vals->destaged)) * 100.0; 693 694 /* miscellaneous */ 695 vals->write_cancellations = 696 FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_WRCANCELNS)); 697 698 vals->total_cache = vals->cache_read + vals->cache_write; 699 vals->total_disk = vals->disk_read + vals->disk_write; 700 701 /* total cache hit calculation */ 702 vals->cache_hit = 0; 703 factors = 0; 704 705 if (vals->cache_read != 0) { 706 vals->cache_hit += vals->read_hit; 707 factors++; 708 } 709 710 if (vals->cache_write != 0) { 711 vals->cache_hit += vals->write_hit; 712 factors++; 713 } 714 715 if (vals->cache_hit) 716 vals->cache_hit /= (float)factors; 717 718 /* adjustments */ 719 divisor = 1; 720 721 if (flags & SDBC_KBYTES) 722 divisor *= KILOBYTE; 723 if ((flags & SDBC_INTAVG) && (etime > 0)) 724 divisor *= etime; 725 726 if (divisor != 1) { 727 vals->cache_read /= divisor; 728 vals->disk_read /= divisor; 729 vals->total_reads /= divisor; 730 731 vals->cache_write /= divisor; 732 vals->disk_write /= divisor; 733 vals->total_writes /= divisor; 734 735 vals->total_cache /= divisor; 736 vals->total_disk /= divisor; 737 738 vals->destaged /= divisor; 739 vals->write_cancellations /= divisor; 740 } 741 742 return (0); 743 } 744 745 /* 746 * sdbc_getdelta() - calculates the difference between two kstat fields 747 * 748 * parameters 749 * sdbcstat_t *sdbcstat - the SDBC stat strcture containing the two fields 750 * char *name - the name of the fields 751 * returns 752 * uint32_t value of the differences adjusted for overflow of the data type 753 */ 754 uint32_t 755 sdbc_getdelta(sdbcstat_t *sdbcstat, char *name) 756 { 757 uint32_t *cur_val; 758 uint32_t *pre_val; 759 760 pre_val = kstat_value(sdbcstat->pre_set, name); 761 cur_val = kstat_value(sdbcstat->cur_set, name); 762 763 return (u32_delta(*pre_val, *cur_val)); 764 } 765 766 void 767 center(int size, char *hdr) 768 { 769 int lpad = 0; 770 int rpad = 0; 771 char fmt[10]; 772 773 if (size == 0) 774 return; 775 776 if (strlen(hdr) < size) { 777 lpad = (size - strlen(hdr)) / 2; 778 779 if (lpad * 2 < size) 780 lpad++; 781 782 rpad = size - (lpad + strlen(hdr)); 783 } 784 785 output: 786 (void) sprintf(fmt, "%%%ds%%s%%%ds", lpad, rpad); 787 (void) printf(fmt, " ", hdr, " "); 788 } 789