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 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <errno.h>
28 #include <stdio.h>
29 #include <unistd.h>
30 #include <strings.h>
31 #include <stdlib.h>
32
33 #include <sys/types.h>
34 #include <sys/time.h>
35 #include <sys/nsctl/sdbc_ioctl.h>
36 #include <sys/nsctl/rdc_ioctl.h>
37 #include <sys/nsctl/sd_bcache.h>
38 #include <sys/nsctl/sd_conf.h>
39 #include <sys/nsctl/rdc_io.h>
40 #include <sys/nsctl/rdc_bitmap.h>
41 #include <sys/unistat/spcs_s_u.h>
42 #include <curses.h>
43
44 static rdc_status_t *rdc_status;
45 static rdc_u_info_t *rdc_info;
46 static int rdc_maxsets;
47 static int rdc_enabled_sets;
48
49 static unsigned prev_time, delta_time;
50 #ifdef m88k
51 extern unsigned *usec_ptr;
52 #endif
53 static int bright = 0;
54
55 extern int sdbc_max_devices;
56
57 extern _sd_stats_t *cs_cur;
58 extern _sd_stats_t *cs_prev;
59 extern _sd_stats_t *cs_persec;
60
61 extern int *on_off;
62 extern int *dual_on_off;
63 extern int *updates_prev;
64 extern double *rate_prev;
65 extern int *samples;
66
67 int range_num = 0;
68 int screen = 0;
69 int dual_screen = 0;
70 static int rnum = 0;
71
72 typedef struct {
73 int lb, ub;
74 } range_t;
75 range_t ranges[100];
76
77 extern int range_first();
78 extern int range_next(int);
79 extern int range_last();
80
81 static int dual_initted = 0;
82 static char status[11][30];
83
84 unsigned dc_delta_time, dc_prev_time;
85
86 #ifdef m88k
87 #define USEC_INIT() usec_ptr = (unsigned int *)timer_init()
88 #define USEC_READ() (*usec_ptr)
89 #else /* !m88k */
90 #define USEC_INIT() USEC_START()
91 #include <sys/time.h>
92 static struct timeval Usec_time;
93 static int Usec_started = 0;
94
95 void total_display(void);
96 void disp_stats(void);
97 void do_calc(void);
98 void init_dual(void);
99 void calc_time(void);
100 void calc_completion(int, int, int);
101 void disp_total_stats(void);
102 void display_cache(void);
103
104 #define DISPLEN 16
105
106 static void
107 USEC_START(void)
108 {
109 if (!Usec_started) {
110 (void) gettimeofday(&Usec_time, NULL);
111 Usec_started = 1;
112 }
113 }
114
115 static unsigned int
116 USEC_READ()
117 {
118 struct timeval tv;
119 if (!Usec_started)
120 USEC_START();
121
122 (void) gettimeofday(&tv, NULL);
123 return (unsigned)((tv.tv_sec - Usec_time.tv_sec) * 1000000 +
124 (tv.tv_usec - Usec_time.tv_usec));
125 }
126 #endif /* m88k */
127
128 #define SAMPLE_RATE 5
129
130 /*
131 * refresh curses window to file
132 */
133 void
134 wrefresh_file(WINDOW *win, int fd)
135 {
136 char buf[8192], c, *cp = buf, *line, *blank, *empty;
137 int x, y;
138
139 empty = NULL; /* cull trailing empty lines */
140 for (y = 0; y < win->_maxy; y++) {
141 line = cp;
142 blank = NULL; /* cull trailing blanks */
143 for (x = 0; x < win->_maxx; x++) {
144 c = (win->_y[y][x]) & A_CHARTEXT;
145 if (c != ' ')
146 blank = NULL;
147 else if (blank == NULL)
148 blank = cp;
149 *cp++ = c;
150 }
151 if (blank)
152 cp = blank;
153 if (line != cp)
154 empty = NULL;
155 else if (empty == NULL)
156 empty = cp + 1;
157 *cp++ = '\n';
158 }
159 if (empty)
160 cp = empty;
161 *cp++ = '\f'; *cp++ = '\n'; *cp = '\0';
162 /* cp is eliminated by short _maxy and _maxx, it won't overflow */
163 /* LINTED, cp - buf won't be > INT32_MAX */
164 (void) write(fd, buf, cp - buf);
165 }
166
167
168 int
169 higher(int high)
170 {
171 int i;
172
173 for (i = high + 1; i <= sdbc_max_devices; i++) {
174 if (cs_cur->st_shared[i].sh_alloc)
175 return (i);
176 }
177 return (0);
178 }
179
180 int
181 is_dirty()
182 {
183 int i, dirty = 0;
184 spcs_s_info_t ustats;
185
186 if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0,
187 &ustats) == SPCS_S_ERROR) {
188 perror("Could not get stats from kernel");
189 if (ustats) {
190 spcs_s_report(ustats, stderr);
191 spcs_s_ufree(&ustats);
192 }
193 return (-errno);
194 }
195 if (cs_cur->st_cachesize == 0)
196 return (0);
197
198 for (i = 0; i < cs_cur->st_count; i++) {
199 if (cs_cur->st_shared[i].sh_alloc)
200 dirty += cs_cur->st_shared[i].sh_numdirty;
201 }
202
203 return (dirty != 0);
204 }
205
206 void
207 display_cache(void)
208 {
209 static int first = 1;
210 spcs_s_info_t ustats;
211
212 if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0, &ustats) ==
213 SPCS_S_ERROR) {
214 perror("sd_stats");
215 if (ustats) {
216 spcs_s_report(ustats, stderr);
217 spcs_s_ufree(&ustats);
218 }
219 }
220
221 do_calc();
222 if (first) {
223 prev_time = USEC_READ();
224 first = 0;
225 } else
226 disp_stats();
227 }
228
229 void
230 total_display(void)
231 {
232 spcs_s_info_t ustats;
233
234 if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0, &ustats) ==
235 SPCS_S_ERROR) {
236 if (ustats) {
237 spcs_s_report(ustats, stderr);
238 spcs_s_ufree(&ustats);
239 }
240 perror("sd_stats");
241 }
242 disp_total_stats();
243 }
244
245
246 int
247 range_first()
248 {
249 rnum = 0;
250 return (ranges[rnum].lb);
251 }
252
253 int
254 range_next(int cd)
255 {
256 if (ranges[rnum].ub > cd)
257 return (cd + 1);
258 if (range_num > rnum)
259 rnum++;
260 else
261 return (cd + 1);
262 return (ranges[rnum].lb);
263 }
264
265 int
266 range_last() {
267 return (ranges[range_num].ub);
268 }
269
270
271 void
272 set_dual_on_off()
273 {
274 int i, j, ct = 0, newct = 0;
275
276 for (i = range_first(); i < rdc_enabled_sets && i <= range_last();
277 i = range_next(i)) {
278 if (rdc_info[i].flags & RDC_ENABLED) {
279 ct++;
280 if (ct > dual_screen * ((LINES - 9) / 2))
281 break;
282 }
283 }
284 if (((i >= rdc_enabled_sets) ||
285 (i > range_last())) && (dual_screen > 0)) {
286 dual_screen--;
287 set_dual_on_off();
288 } else {
289 bzero(dual_on_off, sdbc_max_devices * sizeof (int));
290 for (j = i; j < rdc_enabled_sets && j <= range_last();
291 j = range_next(j)) {
292 if (rdc_info[j].flags & RDC_ENABLED) {
293 newct++;
294 if (newct <= (LINES - 9) / 2) {
295 dual_on_off[j] = 1;
296 } else
297 break;
298 }
299 }
300 }
301 }
302
303
304 void
305 set_on_off()
306 {
307 int i, j, ct = 0, newct = 0;
308
309 for (i = range_first(); i <= range_last(); i = range_next(i)) {
310 if (cs_cur->st_shared[i].sh_alloc) {
311 ct++;
312 if (ct > screen*((LINES - 9) / 2))
313 break;
314 }
315 }
316 if ((i > range_last()) && (screen > 0)) {
317 screen--;
318 set_on_off();
319 } else {
320 bzero(on_off, sdbc_max_devices * sizeof (int));
321 for (j = i; j <= range_last(); j = range_next(j)) {
322 if (cs_cur->st_shared[j].sh_alloc) {
323 newct++;
324 if (newct <= (LINES - 9) / 2)
325 on_off[j] = 1;
326 else
327 break;
328 }
329 }
330 }
331 }
332
333 void
334 disp_stats(void)
335 {
336 double read_s, write_s, access_s, readp, writep;
337 double rmiss_s, wmiss_s;
338 double elapsed = delta_time / 1000000.0;
339 double kbps = elapsed * 1024.0; /* for Kbytes per second */
340 int rtotal, wtotal, i, j;
341 double throughput = 0.0, rthroughput = 0.0;
342 double creads = 0.0, cwrites = 0.0;
343 char status_bit, down = 0;
344 int len;
345 char fn[19];
346
347 if (delta_time != 0) {
348 read_s = cs_persec->st_rdhits / elapsed;
349 write_s = cs_persec->st_wrhits / elapsed;
350 rmiss_s = cs_persec->st_rdmiss / elapsed;
351 wmiss_s = cs_persec->st_wrmiss / elapsed;
352 access_s = (cs_persec->st_wrhits + cs_persec->st_rdhits +
353 cs_persec->st_rdmiss + cs_persec->st_wrmiss) / elapsed;
354 } else
355 read_s = write_s = access_s = 0.0;
356
357 rtotal = cs_persec->st_rdhits + cs_persec->st_rdmiss;
358 wtotal = cs_persec->st_wrhits + cs_persec->st_wrmiss;
359 if (rtotal != 0)
360 readp = cs_persec->st_rdhits / (double)rtotal;
361 else
362 readp = 0.0;
363
364 if (wtotal != 0) {
365 writep = cs_persec->st_wrhits / (double)wtotal;
366 } else
367 writep = 0.0;
368
369 set_on_off();
370 if (cs_cur->st_cachesize == 0)
371 (void) mvprintw(0, 20, "****** Storage Cache Disabled ******");
372 else
373 (void) mvprintw(0, 20, "****** Storage Cache ******");
374 (void) mvprintw(2, 26, "disk_io cache write_blocks");
375 (void) attron(A_UNDERLINE);
376 (void) mvprintw(3, 1, " cd cached_partition reads writes reads writes"
377 " dirty todisk failed");
378 (void) attroff(A_UNDERLINE);
379 for (i = 0, j = 0; j < cs_cur->st_count; i++) {
380 if (i >= sdbc_max_devices)
381 break;
382 if (cs_cur->st_shared[i].sh_alloc) {
383 cs_persec->st_shared[i].sh_disk_write /= kbps;
384 cs_persec->st_shared[i].sh_disk_read /= kbps;
385 cs_persec->st_shared[i].sh_cache_write /= kbps;
386 cs_persec->st_shared[i].sh_cache_read /= kbps;
387 rthroughput += cs_persec->st_shared[i].sh_disk_read;
388 throughput += cs_persec->st_shared[i].sh_disk_write;
389 creads += cs_persec->st_shared[i].sh_cache_read;
390 cwrites += cs_persec->st_shared[i].sh_cache_write;
391 if (!down)
392 down = cs_cur->st_shared[i].sh_failed;
393 if (cs_cur->st_shared[i].sh_failed && bright) {
394 status_bit = '*';
395 } else
396 status_bit = ' ';
397 if ((len = strlen(cs_cur->st_shared[i].sh_filename))
398 > 15) {
399 (void) strcpy(fn, "...");
400 (void) strcat(fn,
401 cs_cur->st_shared[i].sh_filename +
402 len - 12);
403 } else
404 (void) strcpy(fn,
405 cs_cur->st_shared[i].sh_filename);
406 if (on_off[i]) {
407 (void) mvprintw(4 + j, 1,
408 "%3d %-15s%c %6d %6d %6d %6d %6d %6d %6d",
409 cs_cur->st_shared[i].sh_cd,
410 fn,
411 status_bit,
412 cs_persec->st_shared[i].sh_disk_read,
413 cs_persec->st_shared[i].sh_disk_write,
414 cs_persec->st_shared[i].sh_cache_read,
415 cs_persec->st_shared[i].sh_cache_write,
416 cs_cur->st_shared[i].sh_numdirty,
417 cs_cur->st_shared[i].sh_numio,
418 cs_cur->st_shared[i].sh_numfail);
419 j++;
420 }
421 }
422 }
423 bright = !bright;
424
425 (void) mvprintw(4 + j, 22, "------ ------ ------ ------");
426 (void) mvprintw(5 + j, 6, " Kbytes/s total:%6d %6d %6d %6d",
427 (int)rthroughput, (int)throughput,
428 (int)creads, (int)cwrites);
429 (void) mvprintw(7 + j, 1, "accesses/s");
430 (void) mvprintw(7 + j, 15, "read/s write/s %%readh %%writeh");
431
432 (void) attron(A_UNDERLINE);
433 (void) mvprintw(8 + j, 1, " ");
434 (void) mvprintw(8 + j, 13,
435 " ");
436 (void) mvprintw(8 + j, 13, "(misses/s) (misses/s)");
437 (void) attroff(A_UNDERLINE);
438
439 (void) mvprintw(9 + j, 0, "%10.2lf %7.2f %7.2f %6.1f %6.1f",
440 access_s, read_s, write_s, readp * 100.0, writep * 100.0);
441 (void) mvprintw(10 + j, 0, " (%7.2f ) (%7.2f )\n\n",
442 rmiss_s, wmiss_s);
443
444 if (down)
445 (void) mvprintw(20 + j, 1, "* -- disk off-line");
446 }
447
448 void
449 do_calc(void)
450 {
451 int i, j;
452
453 delta_time = USEC_READ() - prev_time;
454
455 cs_persec->st_rdhits = cs_cur->st_rdhits - cs_prev->st_rdhits;
456 cs_persec->st_rdmiss = cs_cur->st_rdmiss - cs_prev->st_rdmiss;
457 cs_persec->st_wrhits = cs_cur->st_wrhits - cs_prev->st_wrhits;
458 cs_persec->st_wrmiss = cs_cur->st_wrmiss - cs_prev->st_wrmiss;
459
460 for (i = 0, j = 0; j < cs_cur->st_count; i++) {
461 if (i >= sdbc_max_devices)
462 break;
463 if (cs_cur->st_shared[i].sh_alloc) {
464 cs_persec->st_shared[i].sh_disk_write =
465 FBA_SIZE(cs_cur->st_shared[i].sh_disk_write -
466 cs_prev->st_shared[i].sh_disk_write);
467 cs_persec->st_shared[i].sh_disk_read =
468 FBA_SIZE(cs_cur->st_shared[i].sh_disk_read -
469 cs_prev->st_shared[i].sh_disk_read);
470 cs_persec->st_shared[i].sh_cache_read =
471 FBA_SIZE(cs_cur->st_shared[i].sh_cache_read -
472 cs_prev->st_shared[i].sh_cache_read);
473 cs_persec->st_shared[i].sh_cache_write =
474 FBA_SIZE(cs_cur->st_shared[i].sh_cache_write -
475 cs_prev->st_shared[i].sh_cache_write);
476 j++;
477 }
478 }
479 (void) memcpy((char *) cs_prev, (char *) cs_cur, sizeof (_sd_stats_t) +
480 (sdbc_max_devices - 1) * sizeof (_sd_shared_t));
481 prev_time = USEC_READ();
482 }
483
484
485 void
486 init_dual(void)
487 {
488 #define IND_ENABLED 0
489 #define IND_RESYNC 1
490 #define IND_RESYNC_REVERSE 2
491 #define IND_VOLUME_DOWN 3
492 #define IND_MIRROR_DOWN 4
493 #define IND_LOGGING 5
494 #define IND_RESYNC_NEEDED 6
495 #define IND_REV_RESYNC_NEEDED 7
496 #define IND_BITMAP_FAILED 8
497 #define IND_FULL_SYNC_NEEDED 9
498 #define IND_FCAL_FAILED 10
499 (void) strcpy(status[IND_ENABLED], "replicating");
500 (void) strcpy(status[IND_RESYNC], "sync");
501 (void) strcpy(status[IND_RESYNC_REVERSE], "rev sync");
502 (void) strcpy(status[IND_VOLUME_DOWN], "volume down");
503 (void) strcpy(status[IND_MIRROR_DOWN], "mirror down");
504 (void) strcpy(status[IND_LOGGING], "logging");
505 (void) strcpy(status[IND_RESYNC_NEEDED], "need sync");
506 (void) strcpy(status[IND_REV_RESYNC_NEEDED], "need rev sync");
507 (void) strcpy(status[IND_BITMAP_FAILED], "bitmap failed");
508 (void) strcpy(status[IND_FULL_SYNC_NEEDED], "full sync needed");
509 (void) strcpy(status[IND_FCAL_FAILED], "fcal failed");
510 dual_initted = 1;
511 }
512
513
514 int
515 rdc_get_maxsets(void)
516 {
517 rdc_status_t rdc_status;
518 spcs_s_info_t ustatus;
519 int rc;
520
521 rdc_status.nset = 0;
522 ustatus = spcs_s_ucreate();
523
524 rc = RDC_IOCTL(RDC_STATUS, &rdc_status, 0, 0, 0, 0, ustatus);
525 spcs_s_ufree(&ustatus);
526
527 if (rc == SPCS_S_ERROR)
528 return (-1);
529
530 return (rdc_status.maxsets);
531 }
532
533 int
534 dual_stats()
535 {
536 int ind, i, k, len;
537 int stars, size, segs;
538 int rdcindex;
539 float pct;
540 char fn[19];
541 char *phost;
542 char *shost;
543 char *pfile;
544 char *sfile;
545 char lhost[16];
546 spcs_s_info_t ustats = NULL;
547
548 (void) gethostname(lhost, 16);
549
550 if (rdc_maxsets <= 0)
551 rdc_maxsets = rdc_get_maxsets();
552
553 if (rdc_maxsets < 0)
554 goto no_stats;
555
556 if (!rdc_status) {
557 rdc_status = malloc(sizeof (rdc_status_t) +
558 (sizeof (rdc_set_t) * (rdc_maxsets - 1)));
559 if (!rdc_status) {
560 no_stats:
561 (void) mvprintw(0, 20,
562 "****** Dual Copy Not Available ******");
563 return (-1);
564 }
565
566 rdc_info = rdc_status->rdc_set;
567 }
568
569 rdc_status->nset = rdc_maxsets;
570 ustats = spcs_s_ucreate();
571
572 size = RDC_IOCTL(RDC_STATUS, rdc_status, 0, 0, 0, 0, ustats);
573 if (size == SPCS_S_ERROR) {
574 if (ustats) {
575 spcs_s_report(ustats, stderr);
576 spcs_s_ufree(&ustats);
577 }
578 (void) mvprintw(0, 20, "****** Dual Copy Not Available ******");
579 return (-1);
580 }
581 spcs_s_ufree(&ustats);
582 rdc_enabled_sets = rdc_status->nset;
583
584 if (!dual_initted)
585 init_dual();
586
587 set_dual_on_off();
588
589 calc_time();
590
591 (void) mvprintw(0, 20, "****** Dual Copy Statistics ******");
592 (void) attron(A_UNDERLINE);
593 (void) mvprintw(2, 0, "primary");
594 (void) mvprintw(2, 22, "link status");
595 (void) mvprintw(2, 36, "secondary");
596 (void) mvprintw(2, 54, "dual copy status");
597 (void) attroff(A_UNDERLINE);
598
599 for (rdcindex = 0, k = 0; rdcindex < rdc_enabled_sets; rdcindex++) {
600 if (!(rdc_info[rdcindex].flags & RDC_ENABLED) ||
601 !dual_on_off[rdcindex])
602 continue;
603
604 if (rdc_info[rdcindex].sync_flags & RDC_VOL_FAILED)
605 ind = IND_VOLUME_DOWN;
606 else if (rdc_info[rdcindex].flags & RDC_FCAL_FAILED)
607 ind = IND_FCAL_FAILED;
608 else if (rdc_info[rdcindex].bmap_flags & RDC_BMP_FAILED)
609 ind = IND_BITMAP_FAILED;
610 else if (rdc_info[rdcindex].flags & RDC_LOGGING) {
611 if (rdc_info[rdcindex].sync_flags &
612 RDC_SYNC_NEEDED)
613 ind = IND_RESYNC_NEEDED;
614 else if (rdc_info[rdcindex].sync_flags &
615 RDC_RSYNC_NEEDED)
616 ind = IND_REV_RESYNC_NEEDED;
617 else
618 ind = IND_LOGGING;
619 } else if ((rdc_info[rdcindex].flags & RDC_SLAVE) &&
620 (rdc_info[rdcindex].flags & RDC_SYNCING)) {
621 if (rdc_info[rdcindex].flags & RDC_PRIMARY)
622 ind = IND_RESYNC_REVERSE;
623 else
624 ind = IND_RESYNC;
625 } else if (rdc_info[rdcindex].flags & RDC_SYNCING) {
626 if (rdc_info[rdcindex].flags & RDC_PRIMARY)
627 ind = IND_RESYNC;
628 else
629 ind = IND_RESYNC_REVERSE;
630 } else
631 ind = IND_ENABLED;
632
633 phost = rdc_info[rdcindex].primary.intf;
634 pfile = rdc_info[rdcindex].primary.file;
635 shost = rdc_info[rdcindex].secondary.intf;
636 sfile = rdc_info[rdcindex].secondary.file;
637
638 if ((len = strlen(phost)) > 8) {
639 (void) mvprintw(4 + k, 0, ".%+7s:",
640 phost + len - 7);
641 } else
642 (void) mvprintw(4 + k, 0, "%+8s:", phost);
643
644 if ((len = strlen(pfile)) > DISPLEN) {
645 (void) mvprintw(4 + k, 9, "...%-13s",
646 pfile + len - DISPLEN + 3);
647 } else
648 (void) mvprintw(4 + k, 9, "%-16s", pfile);
649
650 (void) attron(A_BOLD);
651 (void) mvprintw(4 + k, 26, "*");
652 (void) mvprintw(4 + k, 28, "*");
653
654 (void) mvprintw(4 + k, 56, "%-8s", status[ind]);
655 (void) attroff(A_BOLD);
656
657 if (ind == IND_RESYNC_REVERSE) {
658 if (bright && !(rdc_info[rdcindex].flags & RDC_LOGGING))
659 (void) mvprintw(4 + k, 27, "<");
660 if (rdc_info[rdcindex].flags & RDC_PRIMARY &&
661 !(rdc_info[rdcindex].flags & RDC_LOGGING))
662 calc_completion(rdcindex,
663 rdc_info[rdcindex].bits_set, 4 + k);
664 } else if (ind == IND_RESYNC) {
665 if (bright && !(rdc_info[rdcindex].flags & RDC_LOGGING))
666 (void) mvprintw(4 + k, 27, ">");
667 if (rdc_info[rdcindex].flags & RDC_PRIMARY &&
668 !(rdc_info[rdcindex].flags & RDC_LOGGING))
669 calc_completion(rdcindex,
670 rdc_info[rdcindex].bits_set, 4 + k);
671 } else if (ind == IND_LOGGING)
672 (void) mvprintw(4 + k, 27, ".");
673 else if (ind == IND_ENABLED)
674 (void) mvprintw(4 + k, 27, "=");
675
676 if ((len = strlen(shost)) > 8) {
677 (void) mvprintw(4 + k, 30, ".%+7s:",
678 shost + len - 7);
679 } else
680 (void) mvprintw(4 + k, 30, "%+8s:", shost);
681
682 if ((len = strlen(sfile)) > DISPLEN) {
683 (void) mvprintw(4 + k, 39, "...%-13s",
684 sfile + len - DISPLEN + 3);
685 } else
686 (void) mvprintw(4 + k, 39, "%-16s", sfile);
687
688 k++;
689 }
690
691 k += 5;
692 (void) attron(A_UNDERLINE);
693 for (i = 0; i < 80; i++)
694 (void) mvprintw(k, i, " ");
695 k += 2;
696 (void) mvprintw(k, 0, "partition");
697 (void) mvprintw(k, 16, "recovery needed");
698 (void) mvprintw(k, 48, "recovery completed");
699 (void) attroff(A_UNDERLINE);
700 k += 2;
701
702 for (rdcindex = 0; rdcindex < rdc_enabled_sets; rdcindex++) {
703 if (!(rdc_info[rdcindex].flags & RDC_ENABLED) ||
704 !dual_on_off[rdcindex])
705 continue;
706
707 if (!(rdc_info[rdcindex].flags & RDC_PRIMARY)) {
708 continue;
709 }
710 if (!(rdc_info[rdcindex].flags & RDC_SLAVE) &&
711 !(rdc_info[rdcindex].flags & RDC_SYNCING) &&
712 !(rdc_info[rdcindex].flags & RDC_LOGGING)) {
713 continue;
714 }
715
716 len = strlen(rdc_info[rdcindex].secondary.file);
717 if (len > 15) {
718 (void) strcpy(fn, "...");
719 (void) strcat(fn,
720 rdc_info[rdcindex].secondary.file + len - 12);
721 } else
722 (void) strcpy(fn, rdc_info[rdcindex].secondary.file);
723 (void) mvprintw(k, 0, "%-15s", fn);
724
725 segs = FBA_TO_LOG_LEN(rdc_info[rdcindex].volume_size);
726 pct = segs ?
727 ((float)rdc_info[rdcindex].bits_set / (float)segs) : 0.0;
728 stars = (int)(pct * 20.0);
729 while (stars > 0) {
730 (void) mvprintw(k, 16 + stars, "*");
731 stars--;
732 }
733 (void) attron(A_BOLD);
734 (void) mvprintw(k, 16, "[");
735 (void) mvprintw(k, 37, "]");
736 (void) attroff(A_BOLD);
737 (void) mvprintw(k, 39, "%6.2f%%", pct * 100.0);
738
739 if (rdc_info[rdcindex].flags & RDC_SYNCING)
740 pct = ((float)rdc_info[rdcindex].sync_pos /
741 (float)rdc_info[rdcindex].volume_size);
742 else
743 pct = 0.0;
744 stars = (int)(pct * 20.0);
745 while (stars > 0) {
746 (void) mvprintw(k, 48 + stars, "*");
747 stars--;
748 }
749 (void) attron(A_BOLD);
750 (void) mvprintw(k, 48, "[");
751 (void) mvprintw(k, 69, "]");
752 (void) attroff(A_BOLD);
753 (void) mvprintw(k, 70, "%6.2f%%", pct * 100.0);
754 k++;
755 }
756 bright = !bright;
757 return (0);
758 }
759
760 /*
761 * Calculate a time interval in milliseconds using the
762 * micosecond counter
763 */
764 void
765 calc_time(void)
766 {
767 unsigned int cur;
768
769 cur = USEC_READ();
770 dc_delta_time = cur > dc_prev_time ? cur - dc_prev_time :
771 cur + 0xFFFFFFFF - dc_prev_time;
772 dc_delta_time /= 1000;
773 dc_prev_time = cur;
774 }
775
776 /*
777 * Calculate estimated time of completion of resync
778 */
779 void
780 calc_completion(int cd, int updates_left, int l)
781 {
782 int delta_done;
783 double rate;
784 long time_left;
785 long hours;
786 long minutes;
787 static int initted = 0;
788
789 if (!initted) {
790 updates_prev[cd] = updates_left;
791 initted = 1;
792 return;
793 }
794
795 /*
796 * Caclulate updates since last check
797 */
798 delta_done = updates_prev[cd] - updates_left;
799 updates_prev[cd] = updates_left;
800
801 /*
802 * If no updates, don't bother estimating completion time
803 */
804 if (delta_done <= 0) {
805 samples[cd] = 0;
806 return;
807 }
808
809 rate = delta_done * 1000.0 / dc_delta_time;
810
811 /*
812 * Calculate rate of updates as a weighted average
813 * of previous and current rate
814 */
815 if (rate_prev[cd] && samples[cd] > SAMPLE_RATE)
816 rate = (rate_prev[cd] * 4.0 + rate) / 5.0;
817 rate_prev[cd] = rate;
818 samples[cd]++;
819
820 /*
821 * Get enough samples before making estimate
822 */
823 if (samples[cd]++ < SAMPLE_RATE)
824 return;
825
826 time_left = (long)(updates_left/rate); /* time left in seconds */
827
828 if (time_left < 0)
829 return;
830
831 hours = time_left / (60 * 60);
832 time_left -= hours * (60 * 60);
833 minutes = time_left / 60;
834 time_left -= minutes * 60;
835 (void) mvprintw(l, 67,
836 "time %02d:%02d:%02d \n", hours, minutes, time_left);
837 }
838
839 void
840 disp_total_stats(void)
841 {
842 unsigned int read_s, write_s, access_s;
843 double readp, writep;
844 unsigned int rmiss_s, wmiss_s;
845 double kbps = 2.0;
846 int rtotal, wtotal, i, j;
847 unsigned int throughput = 0, rthroughput = 0, creads = 0, cwrites = 0;
848 char status_bit, down = 0;
849 int len;
850 char fn[19];
851
852 read_s = cs_cur->st_rdhits;
853 write_s = cs_cur->st_wrhits;
854 rmiss_s = cs_cur->st_rdmiss;
855 wmiss_s = cs_cur->st_wrmiss;
856 access_s = (read_s + write_s + rmiss_s + wmiss_s);
857
858 rtotal = cs_cur->st_rdhits + cs_cur->st_rdmiss;
859 wtotal = cs_cur->st_wrhits + cs_cur->st_wrmiss;
860 if (rtotal != 0)
861 readp = cs_cur->st_rdhits / (double)rtotal;
862 else
863 readp = 0.0;
864
865 if (wtotal != 0)
866 writep = cs_cur->st_wrhits / (double)wtotal;
867 else
868 writep = 0.0;
869
870 set_on_off();
871 (void) mvprintw(0, 14,
872 "****** Storage Cache (Cumulative) ******");
873 (void) mvprintw(2, 30, "disk_io cache");
874 (void) attron(A_UNDERLINE);
875 (void) mvprintw(3, 1,
876 " cd cached_partition reads writes reads writes");
877 (void) attroff(A_UNDERLINE);
878 for (i = 0, j = 0; j < cs_cur->st_count; i++) {
879 if (i >= sdbc_max_devices)
880 break;
881 if (cs_cur->st_shared[i].sh_alloc) {
882 cs_cur->st_shared[i].sh_disk_write /= kbps;
883 cs_cur->st_shared[i].sh_disk_read /= kbps;
884 cs_cur->st_shared[i].sh_cache_write /= kbps;
885 cs_cur->st_shared[i].sh_cache_read /= kbps;
886 rthroughput += cs_cur->st_shared[i].sh_disk_read;
887 throughput += cs_cur->st_shared[i].sh_disk_write;
888 creads += cs_cur->st_shared[i].sh_cache_read;
889 cwrites += cs_cur->st_shared[i].sh_cache_write;
890 if (!down)
891 down = cs_cur->st_shared[i].sh_failed;
892 if (cs_cur->st_shared[i].sh_failed && bright)
893 status_bit = '*';
894 else
895 status_bit = ' ';
896 if ((len =
897 strlen(cs_cur->st_shared[i].sh_filename)) > 15) {
898 (void) strcpy(fn, "...");
899 (void) strcat(fn,
900 cs_cur->st_shared[i].sh_filename +
901 len - 12);
902 } else
903 (void) strcpy(fn,
904 cs_cur->st_shared[i].sh_filename);
905
906 if (on_off[i]) {
907 (void) mvprintw(4 + j, 1,
908 "%3d %-15s%c %10u %10u %10u %10u",
909 cs_cur->st_shared[i].sh_cd,
910 fn,
911 status_bit,
912 cs_cur->st_shared[i].sh_disk_read,
913 cs_cur->st_shared[i].sh_disk_write,
914 cs_cur->st_shared[i].sh_cache_read,
915 cs_cur->st_shared[i].sh_cache_write);
916 j++;
917 }
918 }
919 }
920 bright = !bright;
921
922 (void) mvprintw(4 + j, 22,
923 "---------- ---------- ---------- ----------");
924 (void) mvprintw(5 + j, 8, " Kbytes total:%10u %10u %10u %10u",
925 (int)rthroughput, (int)throughput,
926 (int)creads, (int)cwrites);
927 (void) mvprintw(7 + j, 1, " accesses");
928 (void) mvprintw(7 + j, 18, "read write %%readh %%writeh");
929
930 (void) attron(A_UNDERLINE);
931 (void) mvprintw(8 + j, 1, " ");
932 (void) mvprintw(8 + j, 13,
933 " ");
934 (void) mvprintw(8 + j, 11, "( misses) ( misses)");
935 (void) attroff(A_UNDERLINE);
936
937 (void) mvprintw(9 + j, 0, "%10u %10u %10u %6.1f %6.1f",
938 access_s, read_s, write_s, readp*100.0, writep*100.0);
939 (void) mvprintw(10 + j, 0,
940 " (%10u) (%10u)\n\n", rmiss_s, wmiss_s);
941
942 (void) attron(A_UNDERLINE);
943 (void) mvprintw(13 + j, 1, "cachesize blocksize");
944 (void) attroff(A_UNDERLINE);
945 (void) mvprintw(14 + j, 1, "%8dK %10d", cs_cur->st_cachesize / 1024,
946 cs_cur->st_blksize);
947
948 (void) attron(A_UNDERLINE);
949 (void) mvprintw(16 + j, 1, "Write blocks available:");
950 (void) attroff(A_UNDERLINE);
951 (void) mvprintw(17 + j, 1, "Net 0: %6d", cs_cur->st_wlru_inq);
952
953 (void) attron(A_UNDERLINE);
954 (void) mvprintw(19 + j, 1, "LRU stats: Blocks Requeued Optimized");
955 (void) attroff(A_UNDERLINE);
956 (void) mvprintw(20 + j, 7, "%12d %12u %12u", cs_cur->st_lru_blocks,
957 cs_cur->st_lru_req, cs_cur->st_lru_noreq);
958
959 if (down)
960 (void) mvprintw(25 + j, 1, "* -- disk off-line");
961 }