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 }