OpenSolaris_b135/cmd/avs/sdbc/sd_trace.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <strings.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/nsctl/sdbc_ioctl.h>
#include <sys/nsctl/rdc_ioctl.h>
#include <sys/nsctl/sd_bcache.h>
#include <sys/nsctl/sd_conf.h>
#include <sys/nsctl/rdc_io.h>
#include <sys/nsctl/rdc_bitmap.h>
#include <sys/unistat/spcs_s_u.h>
#include <curses.h>
static rdc_status_t *rdc_status;
static rdc_u_info_t *rdc_info;
static int rdc_maxsets;
static int rdc_enabled_sets;
static unsigned prev_time, delta_time;
#ifdef m88k
extern unsigned *usec_ptr;
#endif
static int bright = 0;
extern int sdbc_max_devices;
extern _sd_stats_t *cs_cur;
extern _sd_stats_t *cs_prev;
extern _sd_stats_t *cs_persec;
extern int *on_off;
extern int *dual_on_off;
extern int *updates_prev;
extern double *rate_prev;
extern int *samples;
int range_num = 0;
int screen = 0;
int dual_screen = 0;
static int rnum = 0;
typedef struct {
int lb, ub;
} range_t;
range_t ranges[100];
extern int range_first();
extern int range_next(int);
extern int range_last();
static int dual_initted = 0;
static char status[11][30];
unsigned dc_delta_time, dc_prev_time;
#ifdef m88k
#define USEC_INIT() usec_ptr = (unsigned int *)timer_init()
#define USEC_READ() (*usec_ptr)
#else /* !m88k */
#define USEC_INIT() USEC_START()
#include <sys/time.h>
static struct timeval Usec_time;
static int Usec_started = 0;
void total_display(void);
void disp_stats(void);
void do_calc(void);
void init_dual(void);
void calc_time(void);
void calc_completion(int, int, int);
void disp_total_stats(void);
void display_cache(void);
#define DISPLEN 16
static void
USEC_START(void)
{
if (!Usec_started) {
(void) gettimeofday(&Usec_time, NULL);
Usec_started = 1;
}
}
static unsigned int
USEC_READ()
{
struct timeval tv;
if (!Usec_started)
USEC_START();
(void) gettimeofday(&tv, NULL);
return (unsigned)((tv.tv_sec - Usec_time.tv_sec) * 1000000 +
(tv.tv_usec - Usec_time.tv_usec));
}
#endif /* m88k */
#define SAMPLE_RATE 5
/*
* refresh curses window to file
*/
void
wrefresh_file(WINDOW *win, int fd)
{
char buf[8192], c, *cp = buf, *line, *blank, *empty;
int x, y;
empty = NULL; /* cull trailing empty lines */
for (y = 0; y < win->_maxy; y++) {
line = cp;
blank = NULL; /* cull trailing blanks */
for (x = 0; x < win->_maxx; x++) {
c = (win->_y[y][x]) & A_CHARTEXT;
if (c != ' ')
blank = NULL;
else if (blank == NULL)
blank = cp;
*cp++ = c;
}
if (blank)
cp = blank;
if (line != cp)
empty = NULL;
else if (empty == NULL)
empty = cp + 1;
*cp++ = '\n';
}
if (empty)
cp = empty;
*cp++ = '\f'; *cp++ = '\n'; *cp = '\0';
/* cp is eliminated by short _maxy and _maxx, it won't overflow */
/* LINTED, cp - buf won't be > INT32_MAX */
(void) write(fd, buf, cp - buf);
}
int
higher(int high)
{
int i;
for (i = high + 1; i <= sdbc_max_devices; i++) {
if (cs_cur->st_shared[i].sh_alloc)
return (i);
}
return (0);
}
int
is_dirty()
{
int i, dirty = 0;
spcs_s_info_t ustats;
if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0,
&ustats) == SPCS_S_ERROR) {
perror("Could not get stats from kernel");
if (ustats) {
spcs_s_report(ustats, stderr);
spcs_s_ufree(&ustats);
}
return (-errno);
}
if (cs_cur->st_cachesize == 0)
return (0);
for (i = 0; i < cs_cur->st_count; i++) {
if (cs_cur->st_shared[i].sh_alloc)
dirty += cs_cur->st_shared[i].sh_numdirty;
}
return (dirty != 0);
}
void
display_cache(void)
{
static int first = 1;
spcs_s_info_t ustats;
if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0, &ustats) ==
SPCS_S_ERROR) {
perror("sd_stats");
if (ustats) {
spcs_s_report(ustats, stderr);
spcs_s_ufree(&ustats);
}
}
do_calc();
if (first) {
prev_time = USEC_READ();
first = 0;
} else
disp_stats();
}
void
total_display(void)
{
spcs_s_info_t ustats;
if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0, &ustats) ==
SPCS_S_ERROR) {
if (ustats) {
spcs_s_report(ustats, stderr);
spcs_s_ufree(&ustats);
}
perror("sd_stats");
}
disp_total_stats();
}
int
range_first()
{
rnum = 0;
return (ranges[rnum].lb);
}
int
range_next(int cd)
{
if (ranges[rnum].ub > cd)
return (cd + 1);
if (range_num > rnum)
rnum++;
else
return (cd + 1);
return (ranges[rnum].lb);
}
int
range_last() {
return (ranges[range_num].ub);
}
void
set_dual_on_off()
{
int i, j, ct = 0, newct = 0;
for (i = range_first(); i < rdc_enabled_sets && i <= range_last();
i = range_next(i)) {
if (rdc_info[i].flags & RDC_ENABLED) {
ct++;
if (ct > dual_screen * ((LINES - 9) / 2))
break;
}
}
if (((i >= rdc_enabled_sets) ||
(i > range_last())) && (dual_screen > 0)) {
dual_screen--;
set_dual_on_off();
} else {
bzero(dual_on_off, sdbc_max_devices * sizeof (int));
for (j = i; j < rdc_enabled_sets && j <= range_last();
j = range_next(j)) {
if (rdc_info[j].flags & RDC_ENABLED) {
newct++;
if (newct <= (LINES - 9) / 2) {
dual_on_off[j] = 1;
} else
break;
}
}
}
}
void
set_on_off()
{
int i, j, ct = 0, newct = 0;
for (i = range_first(); i <= range_last(); i = range_next(i)) {
if (cs_cur->st_shared[i].sh_alloc) {
ct++;
if (ct > screen*((LINES - 9) / 2))
break;
}
}
if ((i > range_last()) && (screen > 0)) {
screen--;
set_on_off();
} else {
bzero(on_off, sdbc_max_devices * sizeof (int));
for (j = i; j <= range_last(); j = range_next(j)) {
if (cs_cur->st_shared[j].sh_alloc) {
newct++;
if (newct <= (LINES - 9) / 2)
on_off[j] = 1;
else
break;
}
}
}
}
void
disp_stats(void)
{
double read_s, write_s, access_s, readp, writep;
double rmiss_s, wmiss_s;
double elapsed = delta_time / 1000000.0;
double kbps = elapsed * 1024.0; /* for Kbytes per second */
int rtotal, wtotal, i, j;
double throughput = 0.0, rthroughput = 0.0;
double creads = 0.0, cwrites = 0.0;
char status_bit, down = 0;
int len;
char fn[19];
if (delta_time != 0) {
read_s = cs_persec->st_rdhits / elapsed;
write_s = cs_persec->st_wrhits / elapsed;
rmiss_s = cs_persec->st_rdmiss / elapsed;
wmiss_s = cs_persec->st_wrmiss / elapsed;
access_s = (cs_persec->st_wrhits + cs_persec->st_rdhits +
cs_persec->st_rdmiss + cs_persec->st_wrmiss) / elapsed;
} else
read_s = write_s = access_s = 0.0;
rtotal = cs_persec->st_rdhits + cs_persec->st_rdmiss;
wtotal = cs_persec->st_wrhits + cs_persec->st_wrmiss;
if (rtotal != 0)
readp = cs_persec->st_rdhits / (double)rtotal;
else
readp = 0.0;
if (wtotal != 0) {
writep = cs_persec->st_wrhits / (double)wtotal;
} else
writep = 0.0;
set_on_off();
if (cs_cur->st_cachesize == 0)
(void) mvprintw(0, 20, "****** Storage Cache Disabled ******");
else
(void) mvprintw(0, 20, "****** Storage Cache ******");
(void) mvprintw(2, 26, "disk_io cache write_blocks");
(void) attron(A_UNDERLINE);
(void) mvprintw(3, 1, " cd cached_partition reads writes reads writes"
" dirty todisk failed");
(void) attroff(A_UNDERLINE);
for (i = 0, j = 0; j < cs_cur->st_count; i++) {
if (i >= sdbc_max_devices)
break;
if (cs_cur->st_shared[i].sh_alloc) {
cs_persec->st_shared[i].sh_disk_write /= kbps;
cs_persec->st_shared[i].sh_disk_read /= kbps;
cs_persec->st_shared[i].sh_cache_write /= kbps;
cs_persec->st_shared[i].sh_cache_read /= kbps;
rthroughput += cs_persec->st_shared[i].sh_disk_read;
throughput += cs_persec->st_shared[i].sh_disk_write;
creads += cs_persec->st_shared[i].sh_cache_read;
cwrites += cs_persec->st_shared[i].sh_cache_write;
if (!down)
down = cs_cur->st_shared[i].sh_failed;
if (cs_cur->st_shared[i].sh_failed && bright) {
status_bit = '*';
} else
status_bit = ' ';
if ((len = strlen(cs_cur->st_shared[i].sh_filename))
> 15) {
(void) strcpy(fn, "...");
(void) strcat(fn,
cs_cur->st_shared[i].sh_filename +
len - 12);
} else
(void) strcpy(fn,
cs_cur->st_shared[i].sh_filename);
if (on_off[i]) {
(void) mvprintw(4 + j, 1,
"%3d %-15s%c %6d %6d %6d %6d %6d %6d %6d",
cs_cur->st_shared[i].sh_cd,
fn,
status_bit,
cs_persec->st_shared[i].sh_disk_read,
cs_persec->st_shared[i].sh_disk_write,
cs_persec->st_shared[i].sh_cache_read,
cs_persec->st_shared[i].sh_cache_write,
cs_cur->st_shared[i].sh_numdirty,
cs_cur->st_shared[i].sh_numio,
cs_cur->st_shared[i].sh_numfail);
j++;
}
}
}
bright = !bright;
(void) mvprintw(4 + j, 22, "------ ------ ------ ------");
(void) mvprintw(5 + j, 6, " Kbytes/s total:%6d %6d %6d %6d",
(int)rthroughput, (int)throughput,
(int)creads, (int)cwrites);
(void) mvprintw(7 + j, 1, "accesses/s");
(void) mvprintw(7 + j, 15, "read/s write/s %%readh %%writeh");
(void) attron(A_UNDERLINE);
(void) mvprintw(8 + j, 1, " ");
(void) mvprintw(8 + j, 13,
" ");
(void) mvprintw(8 + j, 13, "(misses/s) (misses/s)");
(void) attroff(A_UNDERLINE);
(void) mvprintw(9 + j, 0, "%10.2lf %7.2f %7.2f %6.1f %6.1f",
access_s, read_s, write_s, readp * 100.0, writep * 100.0);
(void) mvprintw(10 + j, 0, " (%7.2f ) (%7.2f )\n\n",
rmiss_s, wmiss_s);
if (down)
(void) mvprintw(20 + j, 1, "* -- disk off-line");
}
void
do_calc(void)
{
int i, j;
delta_time = USEC_READ() - prev_time;
cs_persec->st_rdhits = cs_cur->st_rdhits - cs_prev->st_rdhits;
cs_persec->st_rdmiss = cs_cur->st_rdmiss - cs_prev->st_rdmiss;
cs_persec->st_wrhits = cs_cur->st_wrhits - cs_prev->st_wrhits;
cs_persec->st_wrmiss = cs_cur->st_wrmiss - cs_prev->st_wrmiss;
for (i = 0, j = 0; j < cs_cur->st_count; i++) {
if (i >= sdbc_max_devices)
break;
if (cs_cur->st_shared[i].sh_alloc) {
cs_persec->st_shared[i].sh_disk_write =
FBA_SIZE(cs_cur->st_shared[i].sh_disk_write -
cs_prev->st_shared[i].sh_disk_write);
cs_persec->st_shared[i].sh_disk_read =
FBA_SIZE(cs_cur->st_shared[i].sh_disk_read -
cs_prev->st_shared[i].sh_disk_read);
cs_persec->st_shared[i].sh_cache_read =
FBA_SIZE(cs_cur->st_shared[i].sh_cache_read -
cs_prev->st_shared[i].sh_cache_read);
cs_persec->st_shared[i].sh_cache_write =
FBA_SIZE(cs_cur->st_shared[i].sh_cache_write -
cs_prev->st_shared[i].sh_cache_write);
j++;
}
}
(void) memcpy((char *) cs_prev, (char *) cs_cur, sizeof (_sd_stats_t) +
(sdbc_max_devices - 1) * sizeof (_sd_shared_t));
prev_time = USEC_READ();
}
void
init_dual(void)
{
#define IND_ENABLED 0
#define IND_RESYNC 1
#define IND_RESYNC_REVERSE 2
#define IND_VOLUME_DOWN 3
#define IND_MIRROR_DOWN 4
#define IND_LOGGING 5
#define IND_RESYNC_NEEDED 6
#define IND_REV_RESYNC_NEEDED 7
#define IND_BITMAP_FAILED 8
#define IND_FULL_SYNC_NEEDED 9
#define IND_FCAL_FAILED 10
(void) strcpy(status[IND_ENABLED], "replicating");
(void) strcpy(status[IND_RESYNC], "sync");
(void) strcpy(status[IND_RESYNC_REVERSE], "rev sync");
(void) strcpy(status[IND_VOLUME_DOWN], "volume down");
(void) strcpy(status[IND_MIRROR_DOWN], "mirror down");
(void) strcpy(status[IND_LOGGING], "logging");
(void) strcpy(status[IND_RESYNC_NEEDED], "need sync");
(void) strcpy(status[IND_REV_RESYNC_NEEDED], "need rev sync");
(void) strcpy(status[IND_BITMAP_FAILED], "bitmap failed");
(void) strcpy(status[IND_FULL_SYNC_NEEDED], "full sync needed");
(void) strcpy(status[IND_FCAL_FAILED], "fcal failed");
dual_initted = 1;
}
int
rdc_get_maxsets(void)
{
rdc_status_t rdc_status;
spcs_s_info_t ustatus;
int rc;
rdc_status.nset = 0;
ustatus = spcs_s_ucreate();
rc = RDC_IOCTL(RDC_STATUS, &rdc_status, 0, 0, 0, 0, ustatus);
spcs_s_ufree(&ustatus);
if (rc == SPCS_S_ERROR)
return (-1);
return (rdc_status.maxsets);
}
int
dual_stats()
{
int ind, i, k, len;
int stars, size, segs;
int rdcindex;
float pct;
char fn[19];
char *phost;
char *shost;
char *pfile;
char *sfile;
char lhost[16];
spcs_s_info_t ustats = NULL;
(void) gethostname(lhost, 16);
if (rdc_maxsets <= 0)
rdc_maxsets = rdc_get_maxsets();
if (rdc_maxsets < 0)
goto no_stats;
if (!rdc_status) {
rdc_status = malloc(sizeof (rdc_status_t) +
(sizeof (rdc_set_t) * (rdc_maxsets - 1)));
if (!rdc_status) {
no_stats:
(void) mvprintw(0, 20,
"****** Dual Copy Not Available ******");
return (-1);
}
rdc_info = rdc_status->rdc_set;
}
rdc_status->nset = rdc_maxsets;
ustats = spcs_s_ucreate();
size = RDC_IOCTL(RDC_STATUS, rdc_status, 0, 0, 0, 0, ustats);
if (size == SPCS_S_ERROR) {
if (ustats) {
spcs_s_report(ustats, stderr);
spcs_s_ufree(&ustats);
}
(void) mvprintw(0, 20, "****** Dual Copy Not Available ******");
return (-1);
}
spcs_s_ufree(&ustats);
rdc_enabled_sets = rdc_status->nset;
if (!dual_initted)
init_dual();
set_dual_on_off();
calc_time();
(void) mvprintw(0, 20, "****** Dual Copy Statistics ******");
(void) attron(A_UNDERLINE);
(void) mvprintw(2, 0, "primary");
(void) mvprintw(2, 22, "link status");
(void) mvprintw(2, 36, "secondary");
(void) mvprintw(2, 54, "dual copy status");
(void) attroff(A_UNDERLINE);
for (rdcindex = 0, k = 0; rdcindex < rdc_enabled_sets; rdcindex++) {
if (!(rdc_info[rdcindex].flags & RDC_ENABLED) ||
!dual_on_off[rdcindex])
continue;
if (rdc_info[rdcindex].sync_flags & RDC_VOL_FAILED)
ind = IND_VOLUME_DOWN;
else if (rdc_info[rdcindex].flags & RDC_FCAL_FAILED)
ind = IND_FCAL_FAILED;
else if (rdc_info[rdcindex].bmap_flags & RDC_BMP_FAILED)
ind = IND_BITMAP_FAILED;
else if (rdc_info[rdcindex].flags & RDC_LOGGING) {
if (rdc_info[rdcindex].sync_flags &
RDC_SYNC_NEEDED)
ind = IND_RESYNC_NEEDED;
else if (rdc_info[rdcindex].sync_flags &
RDC_RSYNC_NEEDED)
ind = IND_REV_RESYNC_NEEDED;
else
ind = IND_LOGGING;
} else if ((rdc_info[rdcindex].flags & RDC_SLAVE) &&
(rdc_info[rdcindex].flags & RDC_SYNCING)) {
if (rdc_info[rdcindex].flags & RDC_PRIMARY)
ind = IND_RESYNC_REVERSE;
else
ind = IND_RESYNC;
} else if (rdc_info[rdcindex].flags & RDC_SYNCING) {
if (rdc_info[rdcindex].flags & RDC_PRIMARY)
ind = IND_RESYNC;
else
ind = IND_RESYNC_REVERSE;
} else
ind = IND_ENABLED;
phost = rdc_info[rdcindex].primary.intf;
pfile = rdc_info[rdcindex].primary.file;
shost = rdc_info[rdcindex].secondary.intf;
sfile = rdc_info[rdcindex].secondary.file;
if ((len = strlen(phost)) > 8) {
(void) mvprintw(4 + k, 0, ".%+7s:",
phost + len - 7);
} else
(void) mvprintw(4 + k, 0, "%+8s:", phost);
if ((len = strlen(pfile)) > DISPLEN) {
(void) mvprintw(4 + k, 9, "...%-13s",
pfile + len - DISPLEN + 3);
} else
(void) mvprintw(4 + k, 9, "%-16s", pfile);
(void) attron(A_BOLD);
(void) mvprintw(4 + k, 26, "*");
(void) mvprintw(4 + k, 28, "*");
(void) mvprintw(4 + k, 56, "%-8s", status[ind]);
(void) attroff(A_BOLD);
if (ind == IND_RESYNC_REVERSE) {
if (bright && !(rdc_info[rdcindex].flags & RDC_LOGGING))
(void) mvprintw(4 + k, 27, "<");
if (rdc_info[rdcindex].flags & RDC_PRIMARY &&
!(rdc_info[rdcindex].flags & RDC_LOGGING))
calc_completion(rdcindex,
rdc_info[rdcindex].bits_set, 4 + k);
} else if (ind == IND_RESYNC) {
if (bright && !(rdc_info[rdcindex].flags & RDC_LOGGING))
(void) mvprintw(4 + k, 27, ">");
if (rdc_info[rdcindex].flags & RDC_PRIMARY &&
!(rdc_info[rdcindex].flags & RDC_LOGGING))
calc_completion(rdcindex,
rdc_info[rdcindex].bits_set, 4 + k);
} else if (ind == IND_LOGGING)
(void) mvprintw(4 + k, 27, ".");
else if (ind == IND_ENABLED)
(void) mvprintw(4 + k, 27, "=");
if ((len = strlen(shost)) > 8) {
(void) mvprintw(4 + k, 30, ".%+7s:",
shost + len - 7);
} else
(void) mvprintw(4 + k, 30, "%+8s:", shost);
if ((len = strlen(sfile)) > DISPLEN) {
(void) mvprintw(4 + k, 39, "...%-13s",
sfile + len - DISPLEN + 3);
} else
(void) mvprintw(4 + k, 39, "%-16s", sfile);
k++;
}
k += 5;
(void) attron(A_UNDERLINE);
for (i = 0; i < 80; i++)
(void) mvprintw(k, i, " ");
k += 2;
(void) mvprintw(k, 0, "partition");
(void) mvprintw(k, 16, "recovery needed");
(void) mvprintw(k, 48, "recovery completed");
(void) attroff(A_UNDERLINE);
k += 2;
for (rdcindex = 0; rdcindex < rdc_enabled_sets; rdcindex++) {
if (!(rdc_info[rdcindex].flags & RDC_ENABLED) ||
!dual_on_off[rdcindex])
continue;
if (!(rdc_info[rdcindex].flags & RDC_PRIMARY)) {
continue;
}
if (!(rdc_info[rdcindex].flags & RDC_SLAVE) &&
!(rdc_info[rdcindex].flags & RDC_SYNCING) &&
!(rdc_info[rdcindex].flags & RDC_LOGGING)) {
continue;
}
len = strlen(rdc_info[rdcindex].secondary.file);
if (len > 15) {
(void) strcpy(fn, "...");
(void) strcat(fn,
rdc_info[rdcindex].secondary.file + len - 12);
} else
(void) strcpy(fn, rdc_info[rdcindex].secondary.file);
(void) mvprintw(k, 0, "%-15s", fn);
segs = FBA_TO_LOG_LEN(rdc_info[rdcindex].volume_size);
pct = segs ?
((float)rdc_info[rdcindex].bits_set / (float)segs) : 0.0;
stars = (int)(pct * 20.0);
while (stars > 0) {
(void) mvprintw(k, 16 + stars, "*");
stars--;
}
(void) attron(A_BOLD);
(void) mvprintw(k, 16, "[");
(void) mvprintw(k, 37, "]");
(void) attroff(A_BOLD);
(void) mvprintw(k, 39, "%6.2f%%", pct * 100.0);
if (rdc_info[rdcindex].flags & RDC_SYNCING)
pct = ((float)rdc_info[rdcindex].sync_pos /
(float)rdc_info[rdcindex].volume_size);
else
pct = 0.0;
stars = (int)(pct * 20.0);
while (stars > 0) {
(void) mvprintw(k, 48 + stars, "*");
stars--;
}
(void) attron(A_BOLD);
(void) mvprintw(k, 48, "[");
(void) mvprintw(k, 69, "]");
(void) attroff(A_BOLD);
(void) mvprintw(k, 70, "%6.2f%%", pct * 100.0);
k++;
}
bright = !bright;
return (0);
}
/*
* Calculate a time interval in milliseconds using the
* micosecond counter
*/
void
calc_time(void)
{
unsigned int cur;
cur = USEC_READ();
dc_delta_time = cur > dc_prev_time ? cur - dc_prev_time :
cur + 0xFFFFFFFF - dc_prev_time;
dc_delta_time /= 1000;
dc_prev_time = cur;
}
/*
* Calculate estimated time of completion of resync
*/
void
calc_completion(int cd, int updates_left, int l)
{
int delta_done;
double rate;
long time_left;
long hours;
long minutes;
static int initted = 0;
if (!initted) {
updates_prev[cd] = updates_left;
initted = 1;
return;
}
/*
* Caclulate updates since last check
*/
delta_done = updates_prev[cd] - updates_left;
updates_prev[cd] = updates_left;
/*
* If no updates, don't bother estimating completion time
*/
if (delta_done <= 0) {
samples[cd] = 0;
return;
}
rate = delta_done * 1000.0 / dc_delta_time;
/*
* Calculate rate of updates as a weighted average
* of previous and current rate
*/
if (rate_prev[cd] && samples[cd] > SAMPLE_RATE)
rate = (rate_prev[cd] * 4.0 + rate) / 5.0;
rate_prev[cd] = rate;
samples[cd]++;
/*
* Get enough samples before making estimate
*/
if (samples[cd]++ < SAMPLE_RATE)
return;
time_left = (long)(updates_left/rate); /* time left in seconds */
if (time_left < 0)
return;
hours = time_left / (60 * 60);
time_left -= hours * (60 * 60);
minutes = time_left / 60;
time_left -= minutes * 60;
(void) mvprintw(l, 67,
"time %02d:%02d:%02d \n", hours, minutes, time_left);
}
void
disp_total_stats(void)
{
unsigned int read_s, write_s, access_s;
double readp, writep;
unsigned int rmiss_s, wmiss_s;
double kbps = 2.0;
int rtotal, wtotal, i, j;
unsigned int throughput = 0, rthroughput = 0, creads = 0, cwrites = 0;
char status_bit, down = 0;
int len;
char fn[19];
read_s = cs_cur->st_rdhits;
write_s = cs_cur->st_wrhits;
rmiss_s = cs_cur->st_rdmiss;
wmiss_s = cs_cur->st_wrmiss;
access_s = (read_s + write_s + rmiss_s + wmiss_s);
rtotal = cs_cur->st_rdhits + cs_cur->st_rdmiss;
wtotal = cs_cur->st_wrhits + cs_cur->st_wrmiss;
if (rtotal != 0)
readp = cs_cur->st_rdhits / (double)rtotal;
else
readp = 0.0;
if (wtotal != 0)
writep = cs_cur->st_wrhits / (double)wtotal;
else
writep = 0.0;
set_on_off();
(void) mvprintw(0, 14,
"****** Storage Cache (Cumulative) ******");
(void) mvprintw(2, 30, "disk_io cache");
(void) attron(A_UNDERLINE);
(void) mvprintw(3, 1,
" cd cached_partition reads writes reads writes");
(void) attroff(A_UNDERLINE);
for (i = 0, j = 0; j < cs_cur->st_count; i++) {
if (i >= sdbc_max_devices)
break;
if (cs_cur->st_shared[i].sh_alloc) {
cs_cur->st_shared[i].sh_disk_write /= kbps;
cs_cur->st_shared[i].sh_disk_read /= kbps;
cs_cur->st_shared[i].sh_cache_write /= kbps;
cs_cur->st_shared[i].sh_cache_read /= kbps;
rthroughput += cs_cur->st_shared[i].sh_disk_read;
throughput += cs_cur->st_shared[i].sh_disk_write;
creads += cs_cur->st_shared[i].sh_cache_read;
cwrites += cs_cur->st_shared[i].sh_cache_write;
if (!down)
down = cs_cur->st_shared[i].sh_failed;
if (cs_cur->st_shared[i].sh_failed && bright)
status_bit = '*';
else
status_bit = ' ';
if ((len =
strlen(cs_cur->st_shared[i].sh_filename)) > 15) {
(void) strcpy(fn, "...");
(void) strcat(fn,
cs_cur->st_shared[i].sh_filename +
len - 12);
} else
(void) strcpy(fn,
cs_cur->st_shared[i].sh_filename);
if (on_off[i]) {
(void) mvprintw(4 + j, 1,
"%3d %-15s%c %10u %10u %10u %10u",
cs_cur->st_shared[i].sh_cd,
fn,
status_bit,
cs_cur->st_shared[i].sh_disk_read,
cs_cur->st_shared[i].sh_disk_write,
cs_cur->st_shared[i].sh_cache_read,
cs_cur->st_shared[i].sh_cache_write);
j++;
}
}
}
bright = !bright;
(void) mvprintw(4 + j, 22,
"---------- ---------- ---------- ----------");
(void) mvprintw(5 + j, 8, " Kbytes total:%10u %10u %10u %10u",
(int)rthroughput, (int)throughput,
(int)creads, (int)cwrites);
(void) mvprintw(7 + j, 1, " accesses");
(void) mvprintw(7 + j, 18, "read write %%readh %%writeh");
(void) attron(A_UNDERLINE);
(void) mvprintw(8 + j, 1, " ");
(void) mvprintw(8 + j, 13,
" ");
(void) mvprintw(8 + j, 11, "( misses) ( misses)");
(void) attroff(A_UNDERLINE);
(void) mvprintw(9 + j, 0, "%10u %10u %10u %6.1f %6.1f",
access_s, read_s, write_s, readp*100.0, writep*100.0);
(void) mvprintw(10 + j, 0,
" (%10u) (%10u)\n\n", rmiss_s, wmiss_s);
(void) attron(A_UNDERLINE);
(void) mvprintw(13 + j, 1, "cachesize blocksize");
(void) attroff(A_UNDERLINE);
(void) mvprintw(14 + j, 1, "%8dK %10d", cs_cur->st_cachesize / 1024,
cs_cur->st_blksize);
(void) attron(A_UNDERLINE);
(void) mvprintw(16 + j, 1, "Write blocks available:");
(void) attroff(A_UNDERLINE);
(void) mvprintw(17 + j, 1, "Net 0: %6d", cs_cur->st_wlru_inq);
(void) attron(A_UNDERLINE);
(void) mvprintw(19 + j, 1, "LRU stats: Blocks Requeued Optimized");
(void) attroff(A_UNDERLINE);
(void) mvprintw(20 + j, 7, "%12d %12u %12u", cs_cur->st_lru_blocks,
cs_cur->st_lru_req, cs_cur->st_lru_noreq);
if (down)
(void) mvprintw(25 + j, 1, "* -- disk off-line");
}