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 <signal.h> 32 #include <setjmp.h> 33 34 #include <kstat.h> 35 36 #include <sys/nsctl/rdc.h> 37 #include <sys/nsctl/rdc_io.h> 38 #include <sys/nsctl/rdc_bitmap.h> 39 40 #include "sdbc_stats.h" 41 #include "sndr_stats.h" 42 43 #include "dsstat.h" 44 #include "common.h" 45 #include "report.h" 46 47 static sndrstat_t *sndr_top; 48 49 void sndr_add_stat(sndrstat_t *); 50 sndrstat_t *sndr_del_stat(sndrstat_t *); 51 52 int sndr_value_check(sndrstat_t *); 53 int sndr_validate(kstat_t *); 54 int sndr_strcmp(char *, char *); 55 int sndr_vol_selected(kstat_t *); 56 57 void getType(kstat_t *, char *); 58 void getStat(kstat_t *, char *); 59 void getQueue(kstat_t *, char *); 60 void printQueueStats(int, kstat_t *); 61 float getSyncNeeded(kstat_t *); 62 63 static void update_sighandler(int); 64 static void discover_sighandler(int); 65 66 static sigjmp_buf update_env, discover_env; 67 static sig_atomic_t sig_raised = 0; 68 /* 69 * sndr_discover() - looks for new statistics to be monitored. 70 * Verifies that any statistics found are now already being 71 * monitored. 72 * 73 */ 74 int 75 sndr_discover(kstat_ctl_t *kc) 76 { 77 static int validated = 0; 78 struct sigaction segv_act; 79 int rc = 0; 80 kstat_t *ksp; 81 82 83 (void) signal(SIGSEGV, discover_sighandler); 84 (void) sigaction(SIGSEGV, NULL, &segv_act); 85 86 /* Loop on all kstats */ 87 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) { 88 int kinst; 89 char kname[KSTAT_STRLEN + 1]; 90 sndrstat_t *cur; 91 sndrstat_t *sndrstat = NULL; 92 kstat_t *bmp_ksp; 93 kstat_t *sec_ksp; 94 95 /* Serach for SNDR set */ 96 if (strcmp(ksp->ks_module, RDC_KSTAT_MODULE) != 0 || 97 strcmp(ksp->ks_name, RDC_KSTAT_INFO) != 0) { 98 continue; 99 } 100 101 if (kstat_read(kc, ksp, NULL) == -1) 102 continue; 103 104 /* 105 * Validate kstat structure 106 */ 107 if (! validated) { 108 if (sndr_validate(ksp)) 109 return (EINVAL); 110 111 validated++; 112 } 113 114 /* 115 * Duplicate check 116 */ 117 for (cur = sndr_top; cur != NULL; cur = cur->next) { 118 char *cur_vname, *tst_vname; 119 uint32_t cur_inst, tst_inst; 120 121 cur_vname = kstat_value(cur->pre_set, RDC_IKSTAT_FILE); 122 cur_inst = cur->pre_set->ks_instance; 123 124 tst_vname = kstat_value(ksp, RDC_IKSTAT_FILE); 125 tst_inst = ksp->ks_instance; 126 127 if (strcmp(cur_vname, tst_vname) == 0 && 128 cur_inst == tst_inst) 129 goto next; 130 } 131 132 /* 133 * Initialize new record 134 */ 135 sndrstat = (sndrstat_t *)calloc(1, sizeof (sndrstat_t)); 136 kinst = ksp->ks_instance; 137 138 /* 139 * Set kstat 140 */ 141 sndrstat->pre_set = kstat_retrieve(kc, ksp); 142 143 if (sndrstat->pre_set == NULL) 144 goto next; 145 146 sndrstat->collected |= GOT_SET_KSTAT; 147 148 /* 149 * Bitmap kstat 150 */ 151 (void) sprintf(kname, "%s%d", RDC_KSTAT_BMPNAME, kinst); 152 153 bmp_ksp = kstat_lookup(kc, RDC_KSTAT_BMPNAME, kinst, kname); 154 sndrstat->pre_bmp = kstat_retrieve(kc, bmp_ksp); 155 156 if (sndrstat->pre_bmp == NULL) 157 goto next; 158 159 sndrstat->collected |= GOT_BMP_KSTAT; 160 161 /* 162 * Secondary kstat 163 */ 164 (void) sprintf(kname, "%s%d", RDC_KSTAT_RDCNAME, kinst); 165 166 sec_ksp = kstat_lookup(kc, RDC_KSTAT_MODULE, kinst, kname); 167 sndrstat->pre_sec = kstat_retrieve(kc, sec_ksp); 168 169 if (sndrstat->pre_sec == NULL) 170 goto next; 171 172 sndrstat->collected |= GOT_SEC_KSTAT; 173 174 next: 175 /* 176 * Check if we got a complete set of stats 177 */ 178 if (sndrstat == NULL) 179 continue; 180 181 if (SNDR_COMPLETE(sndrstat->collected)) { 182 (void) sndr_del_stat(sndrstat); 183 continue; 184 } 185 186 /* 187 * Add to linked list 188 */ 189 sndr_add_stat(sndrstat); 190 } 191 192 (void) sigsetjmp(discover_env, 0); 193 if (sig_raised) { 194 sig_raised = 0; 195 rc = -1; 196 } 197 (void) sigaction(SIGSEGV, &segv_act, NULL); 198 199 return (rc); 200 } 201 202 void 203 discover_sighandler(int sig) 204 { 205 switch (sig) { 206 case SIGSEGV: 207 sig_raised = 1; 208 siglongjmp(discover_env, sig); 209 default: 210 exit(sig); 211 } 212 } 213 214 void 215 update_sighandler(int sig) 216 { 217 switch (sig) { 218 case SIGSEGV: 219 sig_raised = 1; 220 siglongjmp(update_env, sig); 221 default: 222 exit(sig); 223 } 224 } 225 226 /* 227 * sndr_update() - updates all of the statistics currently being monitored. 228 * 229 */ 230 int 231 sndr_update(kstat_ctl_t *kc) 232 { 233 sndrstat_t *cur; 234 struct sigaction segv_act; 235 int rc = 0; 236 237 (void) signal(SIGSEGV, update_sighandler); 238 (void) sigaction(SIGSEGV, NULL, &segv_act); 239 240 for (cur = sndr_top; cur != NULL; cur = cur->next) { 241 int kinst; 242 char kname[KSTAT_STRLEN + 1]; 243 kstat_t *ksp = NULL; 244 char *cur_vname, *tst_vname; 245 246 cur->collected = 0; 247 248 /* 249 * Age off old stats 250 */ 251 if (cur->cur_set != NULL) { 252 kstat_free(cur->pre_set); 253 kstat_free(cur->pre_bmp); 254 kstat_free(cur->pre_sec); 255 256 cur->pre_set = cur->cur_set; 257 cur->pre_bmp = cur->cur_bmp; 258 cur->pre_sec = cur->cur_sec; 259 } 260 261 /* 262 * Set kstat 263 */ 264 (void) strncpy(kname, cur->pre_set->ks_name, KSTAT_STRLEN); 265 kname[KSTAT_STRLEN] = '\0'; 266 267 kinst = cur->pre_set->ks_instance; 268 269 ksp = kstat_lookup(kc, RDC_KSTAT_MODULE, kinst, kname); 270 271 if ((cur->cur_set = kstat_retrieve(kc, ksp)) == NULL) 272 continue; 273 274 cur->collected |= GOT_SET_KSTAT; 275 276 /* 277 * Validate set 278 */ 279 cur_vname = kstat_value(cur->pre_set, RDC_IKSTAT_FILE); 280 tst_vname = kstat_value(cur->cur_set, RDC_IKSTAT_FILE); 281 282 if (strcmp(cur_vname, tst_vname) != 0) 283 continue; 284 285 /* 286 * Bitmap kstat 287 */ 288 (void) sprintf(kname, "%s%d", RDC_KSTAT_BMPNAME, kinst); 289 290 ksp = kstat_lookup(kc, RDC_KSTAT_BMPNAME, kinst, kname); 291 292 if ((cur->cur_bmp = kstat_retrieve(kc, ksp)) == NULL) 293 continue; 294 295 cur->collected |= GOT_BMP_KSTAT; 296 297 /* 298 * Secondary kstat 299 */ 300 (void) sprintf(kname, "%s%d", RDC_KSTAT_RDCNAME, kinst); 301 302 ksp = kstat_lookup(kc, RDC_KSTAT_MODULE, kinst, kname); 303 304 if ((cur->cur_sec = kstat_retrieve(kc, ksp)) == NULL) 305 continue; 306 307 cur->collected |= GOT_SEC_KSTAT; 308 309 } 310 311 (void) sigsetjmp(update_env, 0); 312 if (sig_raised) { 313 sig_raised = 0; 314 rc = -1; 315 } 316 (void) sigaction(SIGSEGV, &segv_act, NULL); 317 318 return (rc); 319 } 320 321 /* 322 * sndr_report() - outputs statistics for the statistics currently being 323 * monitored. Deletes statistics for volumes that have been disabled. 324 * 325 */ 326 int 327 sndr_report() 328 { 329 int padsz; 330 char pad[20] = ""; 331 sndrstat_t *cur, *pre = NULL; 332 333 if (sndr_top == NULL) 334 return (0); 335 336 /* Create padding string for secondary report lines */ 337 padsz = 0; 338 if (dflags & FLAGS) { 339 padsz += STAT_HDR_SIZE; 340 padsz += STAT_HDR_SIZE; 341 } 342 343 if (dflags & ASYNC_QUEUE) 344 padsz += STAT_HDR_SIZE; 345 346 if (dflags & PCTS) 347 padsz += PCT_HDR_SIZE; 348 349 if (padsz) { 350 char fmt[20]; 351 (void) sprintf(fmt, "%%%ds", padsz); 352 (void) sprintf(pad, fmt, " "); 353 } 354 355 for (cur = sndr_top; cur != NULL; ) { /*CSTYLED */ 356 int first = 1; 357 char data[20] = ""; 358 359 /* Check to see if this is this a complete */ 360 if (SNDR_COMPLETE(cur->collected)) { 361 char *c; 362 char vn[NSC_MAXPATH + 1]; 363 sndrstat_t *next; 364 365 /* notify user of set being disabled */ 366 c = kstat_value(cur->pre_set, RDC_IKSTAT_SECFILE); 367 (void) strncpy(vn, c, NSC_MAXPATH); 368 vn[NSC_MAXPATH] = '\0'; 369 370 (void) printf(DATA_C16, vn); 371 (void) printf(" %s\n", RDC_DISABLED); 372 373 next = sndr_del_stat(cur); 374 375 /* free memory and remove stat from list */ 376 if (! pre) 377 cur = sndr_top = next; 378 else 379 cur = pre->next = next; 380 381 continue; 382 } 383 384 /* Check to see if the user specified this volume */ 385 if (! sndr_vol_selected(cur->pre_set)) 386 goto next; 387 388 /* Check to see if zflag applies */ 389 if (zflag && sndr_value_check(cur) == 0) 390 goto next; 391 392 /* Calculate flags */ 393 if (dflags & FLAGS) { 394 char c[STAT_HDR_SIZE]; 395 char vtype[STAT_HDR_SIZE]; 396 char vstat[STAT_HDR_SIZE]; 397 398 getType(cur->cur_set, &c[0]); 399 (void) sprintf(vtype, DATA_C2, c); 400 (void) strcat(data, vtype); 401 402 getStat(cur->cur_set, &c[0]); 403 (void) sprintf(vstat, DATA_C2, c); 404 (void) strcat(data, vstat); 405 } 406 407 /* Async. queue statistics */ 408 if (dflags & ASYNC_QUEUE) { 409 char c[STAT_HDR_SIZE]; 410 char qtype[STAT_HDR_SIZE]; 411 412 getQueue(cur->cur_set, &c[0]); 413 (void) sprintf(qtype, DATA_C2, c); 414 (void) strcat(data, qtype); 415 } 416 417 /* Calculate sync needed percentages */ 418 if (dflags & PCTS) { 419 char snpct[10]; 420 421 (void) sprintf(snpct, DATA_F62, 422 getSyncNeeded(cur->cur_set)); 423 (void) strcat(data, snpct); 424 } 425 426 /* Output */ 427 if (rflags & SNDR_NET) { 428 char *c; 429 char type[STAT_HDR_SIZE]; 430 char vn[NAMED_LEN + 1]; 431 432 getType(cur->cur_set, &type[0]); 433 434 if (type[0] == 'S') { 435 c = kstat_value(cur->pre_set, 436 RDC_IKSTAT_FILE); 437 } else { 438 c = kstat_value(cur->pre_set, 439 RDC_IKSTAT_SECFILE); 440 } 441 442 /* Only print last 15 characters */ 443 if (strlen(c) >= NAMED_LEN) { 444 c += strlen(c) - NAMED_LEN; 445 } 446 (void) strncpy(vn, c, NAMED_LEN); 447 vn[NAMED_LEN] = '\0'; 448 449 header(); 450 (void) printf(DATA_C16, vn); 451 (void) printf("%s", data); 452 (void) printf(ROLE_INF_FMT, RDC_SECONDARY); 453 454 /* Async. queue statistics */ 455 if (dflags & ASYNC_QUEUE) 456 printQueueStats(first, cur->cur_set); 457 458 io_report(cur->cur_sec, cur->pre_sec, 459 sdbc_getstat(vn)); 460 (void) printf("\n"); 461 462 if (first) { 463 (void) strcpy(data, strlen(pad) > 0 ? pad : ""); 464 first = 0; 465 } 466 } 467 468 if (rflags & SNDR_BMP) { 469 char *c; 470 char vn[16]; 471 472 c = kstat_value(cur->pre_set, RDC_IKSTAT_BITMAP); 473 474 /* Only print last 15 characters */ 475 if (strlen(c) >= NAMED_LEN) { 476 c += strlen(c) - NAMED_LEN; 477 } 478 (void) strncpy(vn, c, NAMED_LEN); 479 vn[NAMED_LEN] = '\0'; 480 481 header(); 482 (void) printf(DATA_C16, vn); 483 (void) printf("%s", data); 484 (void) printf(ROLE_INF_FMT, RDC_BITMAP); 485 486 /* Async. queue statistics */ 487 if (dflags & ASYNC_QUEUE) 488 printQueueStats(first, cur->cur_set); 489 490 io_report(cur->cur_bmp, cur->pre_bmp, 491 sdbc_getstat(vn)); 492 (void) printf("\n"); 493 494 if (first) { 495 (void) strcpy(data, strlen(pad) > 0 ? pad : ""); 496 first = 0; 497 } 498 } 499 next: 500 pre = cur; 501 cur = cur->next; 502 } 503 504 return (0); 505 } 506 507 /* 508 * sndr_add_stat() - adds a fully populated sndrstat_t structure 509 * to the linked list of currently monitored kstats. The structure 510 * will be added in alphabetical order, using the volume name as the 511 * key. 512 * 513 * parameters 514 * sndrstat_t *sndrstat - to be added to the list. 515 * 516 */ 517 void 518 sndr_add_stat(sndrstat_t *sndrstat) 519 { 520 521 sndrstat_t *cur; 522 523 if (sndr_top == NULL) { 524 sndr_top = sndrstat; 525 return; 526 } 527 528 for (cur = sndr_top; cur != NULL; cur = cur->next) { 529 char *cur_vname, *nxt_vname, *tst_vname; 530 531 cur_vname = kstat_value(cur->pre_set, RDC_IKSTAT_FILE); 532 tst_vname = kstat_value(sndrstat->pre_set, RDC_IKSTAT_FILE); 533 534 if (strcmp(cur_vname, tst_vname) <= 0) { 535 /* 536 * If we get to the last item in the list, then just 537 * add this one to the end 538 */ 539 if (cur->next == NULL) { 540 cur->next = sndrstat; 541 return; 542 } 543 544 nxt_vname = kstat_value(cur->next->pre_set, 545 RDC_IKSTAT_FILE); 546 547 if (strcmp(nxt_vname, tst_vname) > 0) { 548 sndrstat->next = cur->next; 549 cur->next = sndrstat; 550 return; 551 } 552 } else { 553 if (cur == sndr_top) 554 sndr_top = sndrstat; 555 556 sndrstat->next = cur; 557 558 return; 559 } 560 } 561 } 562 563 /* 564 * sndr_del_stat() - deallocate memory for the structure being 565 * passed in. 566 * 567 * parameters 568 * sndrstat_t *sndrstat - structure to be deallocated 569 * 570 * returns 571 * sndrstat_t * - pointer to the "next" structures in the 572 * linked list. May be NULL if we are removing the last 573 * structure in the linked list. 574 * 575 */ 576 sndrstat_t * 577 sndr_del_stat(sndrstat_t *sndrstat) 578 { 579 580 sndrstat_t *next = sndrstat->next; 581 582 kstat_free(sndrstat->pre_set); 583 kstat_free(sndrstat->pre_bmp); 584 kstat_free(sndrstat->pre_sec); 585 kstat_free(sndrstat->cur_set); 586 kstat_free(sndrstat->cur_bmp); 587 kstat_free(sndrstat->cur_sec); 588 589 free(sndrstat); 590 591 return (next); 592 } 593 594 /* 595 * sndr_value_check() - check to determine if any activity was registered 596 * on this volume by checking the previous stats vs. the current stats. 597 * 598 * parameters 599 * sndrstat_t *sndrstat - structure to be checked 600 * 601 * returns 602 * 0 - no activity 603 * 1 - activity 604 */ 605 int 606 sndr_value_check(sndrstat_t *sndrstat) 607 { 608 if (SNDR_COMPLETE(sndrstat->collected)) 609 return (1); 610 611 if (io_value_check(sndrstat->pre_bmp->ks_data, 612 sndrstat->cur_bmp->ks_data)) { 613 return (1); 614 } 615 616 if (io_value_check(sndrstat->pre_sec->ks_data, 617 sndrstat->cur_sec->ks_data)) { 618 return (1); 619 } 620 621 return (0); 622 } 623 624 /* 625 * sndr_validate() - validates the fields required by dsstat exist in 626 * the kstat_t structure passed in. This check keeps dsstat from 627 * core dumping if the kstat_named_t structures change in any of the 628 * services that dsstat monitors. 629 * 630 * paramaters 631 * kstat_t *ksp - kstat_t structure to check. The ks_data field 632 * should have been populated with a call to kstat_read() 633 * 634 * returns 635 * 0 - all fields are contained in the kstat 636 * 1 - a field required by dsstat is not in the kstat 637 */ 638 int 639 sndr_validate(kstat_t *ksp) 640 { 641 if (! kstat_value(ksp, RDC_IKSTAT_FILE) || 642 ! kstat_value(ksp, RDC_IKSTAT_FLAGS) || 643 ! kstat_value(ksp, RDC_IKSTAT_SYNCFLAGS) || 644 ! kstat_value(ksp, RDC_IKSTAT_BMPFLAGS) || 645 ! kstat_value(ksp, RDC_IKSTAT_VOLSIZE) || 646 ! kstat_value(ksp, RDC_IKSTAT_BITSSET) || 647 ! kstat_value(ksp, RDC_IKSTAT_QUEUE_TYPE) || 648 ! kstat_value(ksp, RDC_IKSTAT_ASYNC_ITEMS) || 649 ! kstat_value(ksp, RDC_IKSTAT_ASYNC_BLOCKS) || 650 ! kstat_value(ksp, RDC_IKSTAT_ASYNC_ITEM_HWM) || 651 ! kstat_value(ksp, RDC_IKSTAT_ASYNC_BLOCK_HWM)) 652 return (1); 653 654 return (0); 655 } 656 657 void 658 getType(kstat_t *ksp, char *vtype) 659 { 660 uint32_t *set_flags; 661 662 set_flags = kstat_value(ksp, RDC_IKSTAT_FLAGS); 663 664 if (*set_flags & RDC_PRIMARY) 665 (void) strcpy(vtype, "P"); 666 else 667 (void) strcpy(vtype, "S"); 668 } 669 670 void 671 getStat(kstat_t *ksp, char *vstat) 672 { 673 uint32_t *set_flags; 674 uint32_t *syn_flags; 675 uint32_t *bmp_flags; 676 677 set_flags = kstat_value(ksp, RDC_IKSTAT_FLAGS); 678 syn_flags = kstat_value(ksp, RDC_IKSTAT_SYNCFLAGS); 679 bmp_flags = kstat_value(ksp, RDC_IKSTAT_BMPFLAGS); 680 681 (void) strcpy(vstat, "R"); 682 683 if (*set_flags & RDC_SYNCING) { 684 if (*set_flags & RDC_SLAVE) 685 if (*set_flags & RDC_PRIMARY) 686 (void) strcpy(vstat, "RS"); 687 else 688 (void) strcpy(vstat, "SY"); 689 else 690 if (*set_flags & RDC_PRIMARY) 691 (void) strcpy(vstat, "SY"); 692 else 693 (void) strcpy(vstat, "RS"); 694 } 695 696 if (*set_flags & RDC_LOGGING) { 697 (void) strcpy(vstat, "L"); 698 699 if (*set_flags & RDC_QUEUING) 700 (void) strcpy(vstat, "Q"); 701 702 if (*set_flags & RDC_DISKQ_FAILED) 703 (void) strcpy(vstat, "QF"); 704 705 if (*syn_flags & RDC_SYNC_NEEDED) 706 (void) strcpy(vstat, "SN"); 707 708 if (*syn_flags & RDC_RSYNC_NEEDED) 709 (void) strcpy(vstat, "RN"); 710 } 711 712 if (*syn_flags & RDC_FCAL_FAILED) 713 (void) strcpy(vstat, "FF"); 714 715 if (*bmp_flags & RDC_BMP_FAILED) 716 (void) strcpy(vstat, "BF"); 717 718 if (*syn_flags & RDC_VOL_FAILED) 719 (void) strcpy(vstat, "VF"); 720 } 721 722 void 723 getQueue(kstat_t *ksp, char *vqueue) 724 { 725 char *qtype; 726 727 (void) strcpy(vqueue, "-"); 728 729 qtype = kstat_value(ksp, RDC_IKSTAT_QUEUE_TYPE); 730 731 if (strcmp(qtype, "memory") == 0) 732 (void) strcpy(vqueue, "M"); 733 734 if (strcmp(qtype, "disk") == 0) 735 (void) strcpy(vqueue, "D"); 736 } 737 738 float 739 getSyncNeeded(kstat_t *ksp) 740 { 741 uint32_t *volsize, *bitsset; 742 uint32_t bits, segs; 743 float pct; 744 745 volsize = kstat_value(ksp, RDC_IKSTAT_VOLSIZE); 746 bitsset = kstat_value(ksp, RDC_IKSTAT_BITSSET); 747 748 segs = FBA_TO_LOG_LEN(*volsize); 749 bits = *bitsset > 0 ? *bitsset : 0; 750 751 pct = segs ? ((float)bits/(float)segs) : 0.0; 752 pct *= 100; 753 754 return (pct); 755 } 756 757 /* 758 * Special handling for compatibility. 759 * "dsstat -s <set>" allows set name to be the last 15 chars, 760 * due to 15 characters limit of old kstat information. 761 * 762 * return 0 if: 763 * 1) full and partial are same 764 * 2) partial is the last 15 chars of full 765 */ 766 int 767 sndr_strcmp(char *full, char *partial) 768 { 769 char *f = full; 770 int rc; 771 772 rc = strcmp(full, partial); 773 774 if (rc != 0 && 775 (strlen(partial) == NAMED_LEN) && 776 (strlen(full) > NAMED_LEN)) { 777 f += strlen(full) - NAMED_LEN; 778 rc = strncmp(f, partial, NAMED_LEN); 779 } 780 781 return (rc); 782 } 783 784 int 785 sndr_vol_selected(kstat_t *ksp) 786 { 787 vslist_t *vslist = vs_top; 788 789 for (vslist = vs_top; vslist != NULL; vslist = vslist->next) { 790 char *vn; 791 char *vh; 792 793 /* If no host specified, check local only */ 794 if (vslist->volhost == NULL) { 795 vn = kstat_value(ksp, RDC_IKSTAT_FILE); 796 797 if (sndr_strcmp(vn, vslist->volname)) 798 continue; 799 else 800 break; 801 } 802 803 /* Check primary */ 804 vn = kstat_value(ksp, RDC_IKSTAT_FILE); 805 vh = kstat_value(ksp, RDC_IKSTAT_PRIMARY_HOST); 806 807 if (sndr_strcmp(vn, vslist->volname) == 0 && 808 sndr_strcmp(vh, vslist->volhost) == 0) 809 break; 810 811 /* Check secondary */ 812 vn = kstat_value(ksp, RDC_IKSTAT_SECFILE); 813 vh = kstat_value(ksp, RDC_IKSTAT_SECONDARY_HOST); 814 815 if (sndr_strcmp(vn, vslist->volname) == 0 && 816 sndr_strcmp(vh, vslist->volhost) == 0) 817 break; 818 } 819 820 if (vs_top != NULL && vslist == NULL) 821 return (0); 822 823 return (1); 824 } 825 826 void 827 printQueueStats(int first, kstat_t *cur_set) 828 { 829 uint32_t *val; 830 831 if (! first) { 832 /* Filler for async. queue fields */ 833 (void) printf(TPS_HDR_FMT, NO_INFO); 834 (void) printf(KPS_HDR_FMT, NO_INFO); 835 (void) printf(TPS_HDR_FMT, NO_INFO); 836 (void) printf(KPS_HDR_FMT, NO_INFO); 837 838 return; 839 } 840 841 val = (uint32_t *)kstat_value(cur_set, RDC_IKSTAT_ASYNC_ITEMS); 842 (void) printf(TPS_INF_FMT, *val); 843 844 val = (uint32_t *)kstat_value(cur_set, RDC_IKSTAT_ASYNC_BLOCKS); 845 (void) printf(KPS_INF_FMT, (float)(*val / 2)); 846 847 val = (uint32_t *)kstat_value(cur_set, RDC_IKSTAT_ASYNC_ITEM_HWM); 848 (void) printf(TPS_INF_FMT, *val); 849 850 val = (uint32_t *)kstat_value(cur_set, RDC_IKSTAT_ASYNC_BLOCK_HWM); 851 (void) printf(KPS_INF_FMT, (float)(*val / 2)); 852 } 853