int fill_cld_args(int argc, char **argv, child_args_t *args)
{
extern char *optarg;
extern int optind;
extern unsigned long glb_flags;
signed char c;
char *leftovers;
while ((c = getopt(argc, argv, "?a:A:B:cC:dD:E:f:Fh:I:K:L:m:M:nN:o:p:P:qQrR:s:S:t:T:wvV:z")) != -1) {
switch(c) {
case ':' :
pMsg(WARN, args, "Missing argument for perameter.\n");
usage();
return(-1);
case 'V' :
#ifdef _DEBUG
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
exit(1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c argument is non numeric.\n", c);
exit(1);
}
gbl_dbg_lvl = atoi(optarg);
#else
pMsg(ERR, args, "Debug code not compiled in, recompile with _DEBUG directive.\n", c);
exit(1);
#endif
break;
case 'd' :
glb_flags |= GLB_FLG_QUIET;
args->flags |= CLD_FLG_DUMP;
break;
case 'a' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->seed = (unsigned int) strtol(optarg, NULL, 0);
break;
case 'A' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
exit(1);
}
if (strchr(optarg,'g')) {
glb_flags |= GLB_FLG_KILL;
}
if (strchr(optarg,'c')) {
args->flags &= ~CLD_FLG_ALLDIE;
}
if (strchr(optarg,'m')) {
args->flags |= CLD_FLG_ERR_MARK;
}
if (strchr(optarg,'r')) {
args->flags &= ~CLD_FLG_ERR_REREAD;
}
if (strchr(optarg,'s')) {
args->flags &= ~CLD_FLG_LBA_SYNC;
}
if (strchr(optarg,'S')) {
args->flags |= CLD_FLG_IO_SERIAL;
}
if (strchr(optarg,'w')) {
args->flags |= CLD_FLG_WRITE_ONCE;
}
if (strchr(optarg,'W')) {
args->flags |= CLD_FLG_UNIQ_WRT;
}
if (strchr(optarg,'t')) {
args->flags |= CLD_FLG_TMO_ERROR;
}
break;
case 'q' :
glb_flags |= GLB_FLG_QUIET;
break;
case 'Q' :
glb_flags |= GLB_FLG_SUPRESS;
break;
case 'v' :
pMsg(INFO, args, "Version %s\n", VER_STR);
exit(0);
case 'p' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (args->flags & (CLD_FLG_LINEAR|CLD_FLG_RANDOM)) {
pMsg(WARN, args, "Only one seek type, -p, can be specified.\n");
return(-1);
}
/* seek pattern type */
if (strchr(optarg,'L'))
args->flags |= CLD_FLG_LINEAR;
else if (strchr(optarg,'l'))
args->flags |= (CLD_FLG_LINEAR|CLD_FLG_NTRLVD);
else if (strchr(optarg,'R'))
args->flags |= CLD_FLG_RANDOM;
else if (strchr(optarg,'r'))
args->flags |= (CLD_FLG_RANDOM|CLD_FLG_NTRLVD);
else {
pMsg(WARN, args, "Unknown Seek pattern\n");
usage();
return(-1);
}
if (strchr(optarg,'U') || strchr(optarg,'u'))
if ((args->flags & (CLD_FLG_LINEAR)) &&
!(args->flags & CLD_FLG_LUND))
args->flags |= CLD_FLG_LUNU;
if (strchr(optarg,'D') || strchr(optarg,'d'))
if ((args->flags & (CLD_FLG_LINEAR)) &&
!(args->flags & CLD_FLG_LUNU))
args->flags |= CLD_FLG_LUND;
break;
case 'B' :
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
if (strchr(optarg,':') != NULL) { /* we are given a range of transfer sizes */
args->flags |= CLD_FLG_RTRSIZ;
args->ltrsiz = strtoul(optarg, &leftovers, 10);
if (leftovers == strchr(leftovers,'k')) { /* first value had a 'k' */
args->ltrsiz *= 2;
leftovers++;
} else if (leftovers == strchr(leftovers, 'm')) { /* first value had a 'm' */
args->ltrsiz *= (2 * 1024);
leftovers++;
} else {
if (args->ltrsiz > 256)
args->ltrsiz /= BLK_SIZE;
}
if (!isdigit(leftovers[1])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->htrsiz = atol((char *)strchr(leftovers,':')+1);
if ((strchr(leftovers,'k')) != NULL) {/* second value had a 'k' */
args->htrsiz *= 2;
} else if ((strchr(leftovers,'m')) != NULL) { /* second value had a 'm' */
args->htrsiz *= (2 * 1024);
} else {
if (args->htrsiz > 256)
args->htrsiz /= BLK_SIZE;
}
} else { /* only a single value given for transfer size */
args->ltrsiz = atoi(optarg);
if (strchr(optarg,'k')) {
args->ltrsiz *= 2;
} else if (strchr(optarg,'m')) {
args->ltrsiz *= (2 * 1024);
} else {
if (args->ltrsiz > 256)
args->ltrsiz /= BLK_SIZE;
}
args->htrsiz = args->ltrsiz;
}
#ifdef _DEBUG
PDBG5(DBUG, args, "Parsed Transfer size: %ld\n", args->htrsiz);
#endif
break;
case 'c' :
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->flags |= CLD_FLG_CPTYPE;
break;
case 'n' :
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->flags |= CLD_FLG_LPTYPE;
break;
case 'f' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->pattern = my_strtofft(optarg);
args->flags |= CLD_FLG_FPTYPE;
break;
case 'F' :
/* the filespec is a list of filespecs in a file */
args->flags |= CLD_FLG_FSLIST;
break;
case 'z' :
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->flags |= CLD_FLG_RPTYPE;
break;
case 'h' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
args->flags |= CLD_FLG_HBEAT;
args->hbeat = atoi(optarg);
if (strchr(optarg,'m')) { /* multiply by sec */
args->hbeat *= 60;
} else if (strchr(optarg,'h')) { /* multiply sec*min */
args->hbeat *= (time_t) (60*60);
} else if (strchr(optarg,'d')) { /* multiply by sec*min*hours */
args->hbeat *= (time_t) (60*60*24);
}
break;
case 'D' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
args->rperc = atoi(optarg);
args->wperc = atoi((char *)(strchr(optarg,':')+1));
args->flags |= CLD_FLG_DUTY;
break;
case 'r' :
args->flags |= CLD_FLG_R;
break;
case 'w' :
args->flags |= CLD_FLG_W;
break;
case 'o' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->offset = atol(optarg);
args->flags |= CLD_FLG_OFFSET;
break;
case 'R' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,':') != NULL) { /* we are given a retry delay */
args->retries = strtol(optarg, &leftovers, 10);
args->retry_delay = (time_t) atol((char *)strchr(leftovers,':')+1);
} else { /* only a retry count given */
args->retries = atoi(optarg);
}
break;
case 'M' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->flags |= CLD_FLG_ALT_MARK;
args->alt_mark = my_strtofft(optarg);
break;
case 'm' :
args->flags |= CLD_FLG_MBLK;
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,'l')) { /* returns NULL if char is not found */
args->flags |= CLD_FLG_MRK_LBA;
}
if (strchr(optarg,'p')) {
args->flags |= CLD_FLG_MRK_PASS;
}
if (strchr(optarg,'t')) {
args->flags |= CLD_FLG_MRK_TIME;
}
if (strchr(optarg,'s')) {
args->flags |= CLD_FLG_MRK_SEED;
}
if (strchr(optarg,'h')) {
args->flags |= CLD_FLG_MRK_HOST;
}
if (strchr(optarg,'f')) {
args->flags |= CLD_FLG_MRK_TARGET;
}
if (strchr(optarg,'a')) {
args->flags |= CLD_FLG_MRK_ALL;
}
if (!strchr(optarg,'l') &&
!strchr(optarg,'p') &&
!strchr(optarg,'t') &&
!strchr(optarg,'s') &&
!strchr(optarg,'h') &&
!strchr(optarg,'f') &&
!strchr(optarg,'a')) {
pMsg(WARN, args, "Unknown header mark option\n");
return(-1);
}
break;
case 'E' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments are non numeric.\n", c);
usage();
return(-1);
}
args->flags |= CLD_FLG_CMPR;
args->cmp_lng = strtol(optarg,NULL,0);
if (strchr(optarg,'k')) { /* multiply by 2^10 */
args->cmp_lng <<= 10;
} else if (strchr(optarg,'K')) { /* multiply 10^3 */
args->cmp_lng *= 1000;
} else if (strchr(optarg,'m')) { /* multiply by 2^20 */
args->cmp_lng <<= 20;
} else if (strchr(optarg,'M')) { /* multiply by 10^6 */
args->cmp_lng *= 1000000;
}
break;
case 'N' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments are non numeric.\n", c);
return(-1);
}
args->flags |= CLD_FLG_VSIZ;
args->vsiz = my_strtofft(optarg);
if (strchr(optarg,'k')) { /* multiply by 2^10 */
args->vsiz <<= 10;
} else if (strchr(optarg,'K')) { /* multiply 10^3 */
args->vsiz *= 1000;
} else if (strchr(optarg,'m')) { /* multiply by 2^20 */
args->vsiz <<= 20;
} else if (strchr(optarg,'M')) { /* multiply by 10^6 */
args->vsiz *= 1000000;
} else if (strchr(optarg,'g')) { /* multiply by 2^30 */
args->vsiz <<= 30;
} else if (strchr(optarg,'G')) { /* multiply by 10^9 */
args->vsiz *= 1000000000;
}
break;
case 'I' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,'R') || strchr(optarg,'r')) {
if (!(args->flags & CLD_FLG_BLK) &&
!(args->flags & CLD_FLG_FILE)) {
args->flags |= CLD_FLG_RAW;
} else {
pMsg(WARN, args, "Can only specify one IO type\n");
return(-1);
}
}
if (strchr(optarg,'B') || strchr(optarg,'b')) {
if (!(args->flags & CLD_FLG_RAW) &&
!(args->flags & CLD_FLG_FILE)) {
args->flags |= CLD_FLG_BLK;
} else {
pMsg(WARN, args, "Can only specify one IO type\n");
return(-1);
}
}
if (strchr(optarg,'F') || strchr(optarg,'f')) {
if (!(args->flags & CLD_FLG_RAW) &&
!(args->flags & CLD_FLG_BLK)) {
args->flags |= CLD_FLG_FILE;
} else {
pMsg(WARN, args, "Can only specify one IO type\n");
return(-1);
}
}
if (strchr(optarg,'D') || strchr(optarg,'d')) {
args->flags |= CLD_FLG_DIRECT;
}
if (strchr(optarg,'s')) {
args->sync_interval = strtoul((char *)strchr(optarg,'s')+1, NULL, 10);
#ifdef _DEBUG
PDBG3(DBUG, args, "Parsed sync interval: %ld\n", args->sync_interval);
#endif
if ((args->flags & CLD_FLG_DIRECT)) {
pMsg(ERR, args, "Can't specify sync with Direct IO\n");
return(-1);
}
args->flags |= CLD_FLG_WFSYNC;
}
break;
case 't' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,':') != NULL) { /* we are given a option for delay & timeout */
args->delayTimeMin = strtoul(optarg, &leftovers, 10);
/* check to see if we have one or more then one ':' */
if ((char *)strchr(optarg,':') == (char *)strrchr(optarg,':')) {
/* only one ':', assume no random delayTime, and ioTimeout */
args->delayTimeMax = args->delayTimeMin;
args->ioTimeout = (time_t) atol((char *)strchr(leftovers,':')+1);
} else {
/* more then one ':', assume random delayTime, and ioTimeout */
args->delayTimeMax = strtoul(leftovers+1, &leftovers, 10);
args->ioTimeout = (time_t) atol((char *)strchr(leftovers,':')+1);
}
if (strchr(leftovers,'m')) { /* multiply by sec */
args->ioTimeout *= 60;
} else if (strchr(leftovers,'h')) { /* multiply sec*min */
args->ioTimeout *= (time_t) (60*60);
} else if (strchr(leftovers,'d')) { /* multiply by sec*min*hours */
args->ioTimeout *= (time_t) (60*60*24);
}
} else {
args->delayTimeMin = strtoul(optarg, (char **)NULL, 10);
args->delayTimeMax = args->delayTimeMin;
}
break;
case 'T' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->run_time = atoi(optarg);
args->flags |= CLD_FLG_TMD;
if (strchr(optarg,'m')) { /* multiply by sec */
args->run_time *= 60;
} else if (strchr(optarg,'h')) { /* multiply sec*min */
args->run_time *= (time_t) (60*60);
} else if (strchr(optarg,'d')) { /* multiply by sec*min*hours */
args->run_time *= (time_t) (60*60*24);
}
break;
case 'L' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->seeks = atoi(optarg);
args->flags |= CLD_FLG_SKS;
if (strchr(optarg,'k')) { /* multiply by 2^10 */
args->seeks <<= 10;
} else if (strchr(optarg,'K')) { /* multiply 10^3 */
args->seeks *= 1000;
} else if (strchr(optarg,'m')) { /* multiply by 2^20 */
args->seeks <<= 20;
} else if (strchr(optarg,'M')) { /* multiply by 10^6 */
args->seeks *= 1000000;
} else if (strchr(optarg,'g')) { /* multiply by 2^30 */
args->seeks <<= 30;
} else if (strchr(optarg,'G')) { /* multiply by 10^9 */
args->seeks *= 1000000000;
}
break;
case 'C' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
args->flags |= CLD_FLG_CYC;
args->cycles = atol(optarg);
break;
case 'K' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
if (atoi(optarg) > MAX_THREADS) {
pMsg(WARN, args, "%u exceeds max of %u threads.\n", atoi(optarg), MAX_THREADS);
return(-1);
}
args->t_kids = atoi(optarg);
break;
case 'P' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,'X')) { /* returns NULL if char is not found */
args->flags |= CLD_FLG_XFERS;
}
if (strchr(optarg,'T')) {
args->flags |= CLD_FLG_TPUTS;
}
if (strchr(optarg,'P')) {
glb_flags |= GLB_FLG_PERFP;
}
if (strchr(optarg,'R')) {
args->flags |= CLD_FLG_RUNT;
}
if (strchr(optarg,'C')) {
args->flags |= CLD_FLG_PCYC;
}
if (strchr(optarg,'A')) {
args->flags |= CLD_FLG_PRFTYPS;
}
if (!strchr(optarg,'P') &&
!strchr(optarg,'A') &&
!strchr(optarg,'X') &&
!strchr(optarg,'R') &&
!strchr(optarg,'C') &&
!strchr(optarg,'T')) {
pMsg(WARN, args, "Unknown performance option\n");
return(-1);
}
break;
case 'S' :
if (!isdigit((int)optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->flags |= CLD_FLG_BLK_RNG;
if (strchr(optarg,':') != NULL) { /* we are given a range */
args->start_blk = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_blk <<= 10;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_blk *= 1000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_blk <<= 20;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_blk *= 1000000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_blk <<= 30;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_blk *= 1000000000;
leftovers++; /* at the ':' */
}
leftovers++; /* should be at the next value */
if (!isdigit((int) leftovers[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->stop_blk = (OFF_T) strtoul(leftovers, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->stop_blk <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->stop_blk *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->stop_blk <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->stop_blk *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->stop_blk <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->stop_blk *= 1000000000;
}
} else { /* only a single value given */
args->start_blk = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_blk <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_blk *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_blk <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_blk *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_blk <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_blk *= 1000000000;
}
}
break;
case 's' :
if (!isdigit((int)optarg[0])) {
pMsg(WARN, args, "-%c argument is non numeric.\n", c);
return(-1);
}
args->flags |= CLD_FLG_LBA_RNG;
if (strchr(optarg,':') != NULL) { /* we are given a range */
args->start_lba = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_lba <<= 10;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_lba *= 1000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_lba <<= 20;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_lba *= 1000000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_lba <<= 30;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_lba *= 1000000000;
leftovers++; /* at the ':' */
}
leftovers++; /* should be at the next value */
if (!isdigit((int) leftovers[0])) {
pMsg(WARN, args, "-%c second argument is non numeric.\n", c);
return(-1);
}
args->stop_lba = (OFF_T) strtoul(leftovers, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->stop_lba <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->stop_lba *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->stop_lba <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->stop_lba *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->stop_lba <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->stop_lba *= 1000000000;
}
} else { /* only a single value given */
args->start_lba = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_lba <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_lba *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_lba <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_lba *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_lba <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_lba *= 1000000000;
}
}
break;
case '?' :
default :
usage();
return(-1);
}
}
if (argv[optind] == NULL) {
pMsg(WARN, args, "Unspecified target.\n");
return(-1);
}
strncpy(args->device, argv[optind], (DEV_NAME_LEN-1));
return 0;
}
void *ChildTimer(void *vtest)
#endif
{
#ifndef WINDOWS
test_ll_t *test = (test_ll_t *) vtest;
#endif
time_t ioTimeoutCount = 0;
time_t total_time = 0;
OFF_T cur_total_io_count = 0;
OFF_T last_total_io_count = 0;
OFF_T tmp_io_count = 0;
time_t run_time = 0;
lvl_t msg_level = WARN;
child_args_t *args = test->args;
test_env_t *env = test->env;
extern int signal_action;
extern unsigned short glb_run;
#ifdef _DEBUG
PDBG3(DBUG, args, "In timer %lu, %d\n", time(NULL), env->bContinue);
#endif
do {
Sleep(1000);
run_time++;
#ifdef _DEBUG
PDBG3(DBUG, args, "Continue timing %lu, %lu, %d\n", time(NULL),
run_time, env->bContinue);
#endif
if (args->flags & CLD_FLG_W) {
if ((args->flags & CLD_FLG_LINEAR)
&& !(args->flags & CLD_FLG_NTRLVD)) {
if (TST_OPER(args->test_state) == WRITER) {
env->hbeat_stats.wtime++;
}
} else {
env->hbeat_stats.wtime++;
}
}
if (args->flags & CLD_FLG_R) {
if ((args->flags & CLD_FLG_LINEAR)
&& !(args->flags & CLD_FLG_NTRLVD)) {
if (TST_OPER(args->test_state) == READER) {
env->hbeat_stats.rtime++;
}
} else {
env->hbeat_stats.rtime++;
}
}
/*
* Check to see if we have made any IO progress in the last interval,
* if not incremment the ioTimeout timer, otherwise, clear it
*/
cur_total_io_count = env->global_stats.wcount
+ env->cycle_stats.wcount
+ env->hbeat_stats.wcount
+ env->global_stats.rcount
+ env->cycle_stats.rcount + env->hbeat_stats.rcount;
if (cur_total_io_count == 0) {
tmp_io_count = 1;
} else {
tmp_io_count = cur_total_io_count;
}
total_time = env->global_stats.rtime
+ env->cycle_stats.rtime
+ env->hbeat_stats.rtime
+ env->global_stats.wtime
+ env->cycle_stats.wtime + env->hbeat_stats.wtime;
#ifdef _DEBUG
PDBG3(DBUG, args, "average number of seconds per IO: %0.8lf\n",
((double)(total_time) / (double)(tmp_io_count)));
#endif
if (cur_total_io_count == last_total_io_count) { /* no IOs completed in interval */
if (0 == (++ioTimeoutCount % args->ioTimeout)) { /* no progress after modulo ioTimeout interval */
if (args->flags & CLD_FLG_TMO_ERROR) {
args->test_state =
SET_STS_FAIL(args->test_state);
env->bContinue = FALSE;
msg_level = ERR;
}
pMsg(msg_level, args,
"Possible IO hang condition, IO timeout reached, %lu seconds\n",
args->ioTimeout);
}
#ifdef _DEBUG
PDBG3(DBUG, args, "io timeout count: %lu\n",
ioTimeoutCount);
#endif
} else {
ioTimeoutCount = 0;
last_total_io_count = cur_total_io_count;
#ifdef _DEBUG
PDBG3(DBUG, args, "io timeout reset\n");
#endif
}
if (((args->hbeat > 0) && ((run_time % args->hbeat) == 0))
|| (signal_action & SIGNAL_STAT)) {
print_stats(args, env, HBEAT);
update_cyc_stats(env);
clear_stat_signal();
}
if (glb_run == 0) {
break;
} /* global run flag cleared */
if (signal_action & SIGNAL_STOP) {
break;
}
/* user request to stop */
if (args->flags & CLD_FLG_TMD) { /* if timing */
if (run_time >= args->run_time) { /* and run time exceeded */
break;
}
} else { /* if not timing */
if (env->kids <= 1) { /* and the timer is the only child */
break;
}
}
} while (TRUE);
#ifdef _DEBUG
PDBG3(DBUG, args, "Out of timer %lu, %lu, %d, %d\n", time(NULL),
run_time, env->bContinue, env->kids);
#endif
if (args->flags & CLD_FLG_TMD) { /* timed test, timer exit needs to stop io threads */
#ifdef _DEBUG
PDBG3(DBUG, args,
"Setting bContinue to FALSE, timed test & timer exit\n");
#endif
env->bContinue = FALSE;
}
TEXIT((uintptr_t) GETLASTERROR());
}
