void
parse_opts(int argc, char *argv[])
{
extern char *optarg;
int c;
while ((c = getopt(argc, argv, "b:d:l:r:Rf:")) != -1) {
switch (c) {
case 'f':
/* printf("\n%s", optarg); */
(void) strcpy(config_file, optarg);
break;
case 'b':
/* bufsize between 1*512 and 512*512 */
bufsize = strtol(optarg, 0, 0);
if (bufsize > (MAXBUF*4))
bufsize = MAXBUF*4;
else if (bufsize < FBA_SIZE(1))
bufsize = FBA_SIZE(1);
break;
case 'd':
/* convert datasize from Mb's to fba */
fsize = strtol(optarg, 0, 0) * FBA_NUM(1 << 20);
break;
case 'l':
loops = (nsc_size_t)strtoll(optarg, 0, 0);
break;
case 'r':
/* count of readers for test 7 */
readercount = strtol(optarg, 0, 0);
break;
case 'R':
/* do reserve, release on a per io basis */
Rflag = 0;
break;
case '?':
print_usage();
exit(0);
}
}
bufsize &= ~FBA_MASK; /* multiple of 512 bytes for SECTMODE I/O */
fba_num_bufsize = FBA_NUM(bufsize);
/* set #ios for random io tests */
if (loops != 0)
r_loops = loops;
}
static int
_sd_copy_pattern_to_handle(_sd_buf_handle_t *handle, nsc_off_t fba_pos,
nsc_size_t fba_len)
{
sdbc_cblk_fba_t st_cblk_len; /* FBA len of starting cache block */
sdbc_cblk_fba_t end_cblk_len; /* FBA len of ending cache block */
sdbc_cblk_fba_t st_cblk_off; /* FBA offset into starting cblock */
nsc_size_t cur_fba_len;
int i;
_sd_cctl_t *cc_ent;
cc_ent = handle->bh_centry;
while (CENTRY_BLK(cc_ent) != FBA_TO_BLK_NUM(fba_pos))
cc_ent = cc_ent->cc_chain;
cur_fba_len = fba_len;
st_cblk_off = BLK_FBA_OFF(fba_pos);
st_cblk_len = (BLK_FBAS - st_cblk_off);
if ((nsc_size_t)st_cblk_len >= fba_len) {
end_cblk_len = 0;
st_cblk_len = (sdbc_cblk_fba_t)fba_len;
} else
end_cblk_len = BLK_FBA_OFF(fba_pos + fba_len);
for (i = 0; i < (int)FBA_SIZE(st_cblk_len); i += 4)
*((uint_t *)(void *)(cc_ent->cc_data + FBA_SIZE(st_cblk_off) +
i)) = nsc_usec();
cur_fba_len -= st_cblk_len;
cc_ent = cc_ent->cc_chain;
while (cur_fba_len > (nsc_size_t)end_cblk_len) {
for (i = 0; i < CACHE_BLOCK_SIZE; i += 4) {
unsigned int usec = nsc_usec();
bcopy(&usec, cc_ent->cc_data + i, 4);
}
cc_ent = cc_ent->cc_chain;
cur_fba_len -= BLK_FBAS;
}
if (cur_fba_len) {
for (i = 0; i < (int)FBA_SIZE(end_cblk_len); i += 4) {
unsigned int usec = nsc_usec();
bcopy(&usec, cc_ent->cc_data + i, 4);
}
}
return (0);
}
static int
_nsc_copy_h(nsc_buf_t *h1, nsc_buf_t *h2, nsc_off_t pos1,
nsc_off_t pos2, nsc_size_t len)
{
nsc_vec_t *v1, *v2;
uchar_t *a1, *a2;
int sz, l1, l2, lenbytes; /* byte sizes within an nsc_vec_t */
if (pos1 < h1->sb_pos || pos1 + len > h1->sb_pos + h1->sb_len ||
pos2 < h2->sb_pos || pos2 + len > h2->sb_pos + h2->sb_len)
return (EINVAL);
if (!len)
return (0);
/* find starting point in "from" vector */
v1 = h1->sb_vec;
pos1 -= h1->sb_pos;
for (; pos1 >= FBA_NUM(v1->sv_len); v1++)
pos1 -= FBA_NUM(v1->sv_len);
a1 = v1->sv_addr + FBA_SIZE(pos1);
l1 = v1->sv_len - FBA_SIZE(pos1);
/* find starting point in "to" vector */
v2 = h2->sb_vec;
pos2 -= h2->sb_pos;
for (; pos2 >= FBA_NUM(v2->sv_len); v2++)
pos2 -= FBA_NUM(v2->sv_len);
a2 = v2->sv_addr + FBA_SIZE(pos2);
l2 = v2->sv_len - FBA_SIZE(pos2);
/* copy required data */
ASSERT(FBA_SIZE(len) < INT_MAX);
lenbytes = (int)FBA_SIZE(len);
while (lenbytes) {
sz = min(l1, l2);
sz = min(sz, lenbytes);
bcopy(a1, a2, sz);
l1 -= sz; l2 -= sz;
a1 += sz; a2 += sz;
lenbytes -= sz;
if (!l1)
a1 = (++v1)->sv_addr, l1 = v1->sv_len;
if (!l2)
a2 = (++v2)->sv_addr, l2 = v2->sv_len;
}
return (0);
}
/*
* cfg_open
* Open the current configuration file
* Sets file descriptor in cfp->cf_fd for use by other routines
*/
cfp_t *
localcf_open(cfp_t *cfp, char *name)
{
struct stat sb;
int rc;
if (name == NULL) {
cfg_perror_str = dgettext("cfg",
"cfg_open: unable to open configuration location");
cfg_severity = CFG_EFATAL;
return (NULL);
}
cfp->cf_fd = open(name, O_RDWR|O_CREAT|O_DSYNC|O_RSYNC, 0640);
if (cfp->cf_fd == -1) {
if ((cfp->cf_fd = open(name, O_RDONLY, 0640)) == -1) {
cfg_perror_str = dgettext("cfg",
"cfg_open: unable to open configuration location");
cfg_severity = CFG_EFATAL;
return (NULL);
}
cfp->cf_flag |= CFG_RDONLY;
}
if (fstat(cfp->cf_fd, &sb) == -1) {
close(cfp->cf_fd);
cfg_perror_str = dgettext("cfg",
"cfg_open: unable to stat configuration location");
cfg_severity = CFG_EFATAL;
return (NULL);
}
if (S_ISBLK(sb.st_mode) || S_ISCHR(sb.st_mode)) {
cfp->cf_size = get_bsize(cfp, name);
/* skip the vtoc if necessary */
if (cfp->cf_flag & CFG_NOWRVTOC) {
do {
rc = lseek(cfp->cf_fd, CFG_VTOC_SKIP, SEEK_SET);
} while (rc == -1 && errno == EINTR);
if (rc == -1) {
cfg_perror_str = dgettext("cfg",
strerror(errno));
cfg_severity = CFG_EFATAL;
close(cfp->cf_fd);
return (NULL);
}
}
} else if (S_ISREG(sb.st_mode)) {
cfp->cf_flag |= CFG_FILE;
cfp->cf_size = FBA_NUM(FBA_SIZE(1) - 1 + sb.st_size);
} else {
cfg_perror_str = dgettext("cfg", "cfg_open: unknown file type");
cfg_severity = CFG_EFATAL;
close(cfp->cf_fd);
cfp->cf_fd = NULL;
return (NULL);
}
return (cfp);
}
/*
* sdbc_getvalues() - populates a values structure with data obtained from the
* kstat
*
* parameters
* sdbcstat_t *sdbcstat - pointer to the structure containing the kstats
* sdbcvals_t *vals - pointer to the structure that will receive the values
* int flags - flags that describe adjustments made to the values
*
* returns
* 1 - failure
* 0 - success
*/
int
sdbc_getvalues(sdbcstat_t *sdbcstat, sdbcvals_t *vals, int flags)
{
int divisor = 0;
int factors;
uint64_t hr_etime;
double etime;
kstat_io_t *cur;
kstat_io_t *pre;
if (sdbcstat == NULL)
return (1);
cur = sdbcstat->cur_io->ks_data;
pre = sdbcstat->pre_io->ks_data;
hr_etime = hrtime_delta(pre->rlastupdate, cur->rlastupdate);
etime = hr_etime / (double)NANOSEC;
/* read data */
vals->cache_read =
FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_CACHE_READ));
vals->disk_read =
FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DISK_READ));
vals->total_reads = vals->cache_read + vals->disk_read;
if (vals->cache_read == 0)
vals->read_hit = 0.0;
else
vals->read_hit =
((float)vals->cache_read / vals->total_reads) * 100.0;
/* write data */
vals->cache_write =
FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_CACHE_WRITE));
vals->disk_write =
FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DISK_WRITE));
vals->total_writes = vals->cache_write + vals->disk_write;
vals->destaged =
FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_DESTAGED));
if (vals->cache_write == 0)
vals->write_hit = 0.0;
else
vals->write_hit = ((float)vals->cache_write /
(vals->total_writes - vals->destaged)) * 100.0;
/* miscellaneous */
vals->write_cancellations =
FBA_SIZE(sdbc_getdelta(sdbcstat, SDBC_CDKSTAT_WRCANCELNS));
vals->total_cache = vals->cache_read + vals->cache_write;
vals->total_disk = vals->disk_read + vals->disk_write;
/* total cache hit calculation */
vals->cache_hit = 0;
factors = 0;
if (vals->cache_read != 0) {
vals->cache_hit += vals->read_hit;
factors++;
}
if (vals->cache_write != 0) {
vals->cache_hit += vals->write_hit;
factors++;
}
if (vals->cache_hit)
vals->cache_hit /= (float)factors;
/* adjustments */
divisor = 1;
if (flags & SDBC_KBYTES)
divisor *= KILOBYTE;
if ((flags & SDBC_INTAVG) && (etime > 0))
divisor *= etime;
if (divisor != 1) {
vals->cache_read /= divisor;
vals->disk_read /= divisor;
vals->total_reads /= divisor;
vals->cache_write /= divisor;
vals->disk_write /= divisor;
vals->total_writes /= divisor;
vals->total_cache /= divisor;
vals->total_disk /= divisor;
vals->destaged /= divisor;
vals->write_cancellations /= divisor;
}
return (0);
}
/* ARGSUSED3 */
static void
_sd_direct_test(int c, int loop, int seed, int type)
{
nsc_size_t filesize;
int loops;
int cd;
int ckd_hd, recs, rec_size, ckd_doz;
int done_size;
clock_t st_time;
int i;
int ckd_hd_sz, rec_bsz;
int print_stuff;
int throttle;
struct buf *bp;
nsc_off_t curpos;
caddr_t caddr;
iosent = 0;
print_stuff = 0;
seed = gld[c].seed;
rec_size = (seed & 0xff);
recs = (seed & 0xf00)>>8;
ckd_hd = (seed & 0xf000)>>12;
ckd_doz = (seed & 0xf0000)>>16;
throttle = (seed & 0xff00000)>>20;
ckd_hd_sz = ckd_hd * 512;
rec_bsz = rec_size * 512;
done_size = 0;
tiodone = 0;
curpos = 0;
tioerr = 0;
if (strlen(devarray[c]) == 0) {
cmn_err(CE_WARN, "!child %d devarray null\n", c);
return;
}
if ((cd = _sd_open(devarray[c], dev_flag[c])) < 0) {
cmn_err(CE_WARN, "!Open error %s child %d\n", devarray[c], c);
return;
}
caddr = (caddr_t)nsc_kmem_alloc(20 * 8192, KM_SLEEP, sdbc_local_mem);
(void) _sd_get_partsize((blind_t)(unsigned long)cd, &filesize);
filesize = FBA_SIZE(filesize);
loops = ((nsc_size_t)loop > (filesize / (60 * 1024))) ?
(filesize / (60 * 1024)) : loop;
st_time = nsc_usec();
cmn_err(CE_CONT, "!Test 100: %s file %d cd %d loops %x seed\n",
devarray[c], cd, loop, seed);
cmn_err(CE_CONT,
"!Test 100: %d recsize %d recs %d throttle %d hd %d doz\n",
rec_size, recs, throttle, ckd_hd, ckd_doz);
for (i = 0; i < loops; i++) {
curpos = i * 120;
if (ckd_doz) {
bp = sd_alloc_iob(_sd_cache_files[cd].cd_crdev,
curpos, 20, B_WRITE);
sd_add_mem(bp, caddr, ckd_hd_sz);
(void) sd_start_io(bp,
_sd_cache_files[cd].cd_strategy, myend, NULL);
iosent++;
curpos += ckd_sskip;
}
if (ckd_doz == 2) {
bp = sd_alloc_iob(_sd_cache_files[cd].cd_crdev,
curpos, 20, B_WRITE);
sd_add_mem(bp, caddr, 4096-ckd_sskip*512);
(void) sd_start_io(bp,
_sd_cache_files[cd].cd_strategy, myend, NULL);
iosent++;
curpos += 4096-ckd_sskip*512;
}
bp = sd_alloc_iob(_sd_cache_files[cd].cd_crdev,
curpos, 20, B_WRITE);
sd_add_mem(bp, caddr, recs * rec_bsz);
(void) sd_start_io(bp,
_sd_cache_files[cd].cd_strategy, myend, NULL);
iosent++;
done_size += recs * rec_bsz;
if (tiodone && ((tiodone / 300) > print_stuff)) {
cmn_err(CE_CONT, "!Done %d ios %d size in %lu time\n",
tiodone,
ckd_doz ? ((ckd_doz == 2) ?
(tiodone * (recs * rec_bsz + 4096)) / 3:
(tiodone * (recs * rec_bsz + ckd_hd_sz)) / 2) :
(tiodone * (recs * rec_bsz)),
(nsc_usec() - st_time) / 1000);
print_stuff++;
}
while ((iosent - (tiodone + tioerr)) > throttle)
;
}
while ((tiodone + tioerr) < iosent) {
if (tiodone && ((tiodone / 300) > print_stuff)) {
cmn_err(CE_CONT, "!Done %d ios %d size in %lu time\n",
tiodone,
ckd_doz ? ((ckd_doz == 2) ?
(tiodone * (recs * rec_bsz + 4096)) / 3:
(tiodone * (recs * rec_bsz + ckd_hd_sz)) / 2) :
(tiodone * (recs * rec_bsz)),
(nsc_usec() - st_time) / 1000);
print_stuff++;
}
}
cmn_err(CE_CONT, "!Done %d ios %d size in %lu time\n",
tiodone,
ckd_doz ? ((ckd_doz == 2) ?
(tiodone * (recs * rec_bsz + 4096)) / 3:
(tiodone * (recs * rec_bsz + ckd_hd_sz)) / 2) :
(tiodone * (recs * rec_bsz)),
(nsc_usec() - st_time) / 1000);
print_stuff++;
nsc_kmem_free(caddr, 20 * 8192);
}
static int
_sd_compare_handle(_sd_buf_handle_t *handle1, _sd_buf_handle_t *handle2,
nsc_off_t fba_pos1, nsc_off_t fba_pos2, nsc_size_t fba_len, int skew)
{
sdbc_cblk_fba_t st_cblk_len; /* FBA len of starting cache block */
sdbc_cblk_fba_t end_cblk_len; /* FBA len of ending cache block */
sdbc_cblk_fba_t st_cblk_off; /* FBA offset into starting cblock */
nsc_size_t cur_fba_len;
_sd_cctl_t *cc_ent, *cc_ent1;
unsigned char *skew_word;
int skew_count = 0;
ASSERT_HANDLE_LIMITS(handle1, fba_pos1, fba_len);
ASSERT_HANDLE_LIMITS(handle2, fba_pos2, fba_len);
cc_ent = handle1->bh_centry;
while (CENTRY_BLK(cc_ent) != FBA_TO_BLK_NUM(fba_pos1))
cc_ent = cc_ent->cc_chain;
cc_ent1 = handle2->bh_centry;
while (CENTRY_BLK(cc_ent1) != FBA_TO_BLK_NUM(fba_pos2))
cc_ent1 = cc_ent1->cc_chain;
if (BLK_FBA_OFF(fba_pos1) != BLK_FBA_OFF(fba_pos2)) {
cmn_err(CE_WARN, "!Cannot compare unaligned handles");
return (0);
}
cur_fba_len = fba_len;
st_cblk_off = BLK_FBA_OFF(fba_pos1);
st_cblk_len = (BLK_FBAS - st_cblk_off);
if ((nsc_size_t)st_cblk_len >= fba_len) {
end_cblk_len = 0;
st_cblk_len = (sdbc_cblk_fba_t)fba_len;
} else
end_cblk_len = BLK_FBA_OFF(fba_pos1 + fba_len);
skew_word = cc_ent->cc_data + FBA_SIZE(st_cblk_off);
*skew_word = skew | (++skew_count << 24);
if (bcmp(cc_ent->cc_data + FBA_SIZE(st_cblk_off),
cc_ent1->cc_data + FBA_SIZE(st_cblk_off),
FBA_SIZE(st_cblk_len)) != 0)
cmn_err(CE_WARN, "!Data mismatch fba_pos:%" NSC_SZFMT,
fba_pos2);
cur_fba_len -= st_cblk_len;
cc_ent = cc_ent->cc_chain;
cc_ent1 = cc_ent1->cc_chain;
while (cur_fba_len > (nsc_size_t)end_cblk_len) {
skew_word = cc_ent->cc_data;
*skew_word = skew | (++skew_count << 24);
if (bcmp(cc_ent->cc_data, cc_ent1->cc_data,
CACHE_BLOCK_SIZE) != 0)
cmn_err(CE_WARN, "!Data mismatch fba_pos:%" NSC_SZFMT,
fba_pos2);
cc_ent = cc_ent->cc_chain;
cc_ent1 = cc_ent1->cc_chain;
cur_fba_len -= BLK_FBAS;
}
if (cur_fba_len) {
skew_word = cc_ent->cc_data;
*skew_word = skew | (++skew_count << 24);
if (bcmp(cc_ent->cc_data, cc_ent1->cc_data,
FBA_SIZE(end_cblk_len)) != 0)
cmn_err(CE_WARN, "!Data mismatch fba_pos:%" NSC_SZFMT,
fba_pos2);
}
return (0);
}
