xref: /external/ltp/testcases/kernel/io/disktest/parse.c

/*
* Disktest
* Copyright (c) International Business Machines Corp., 2001
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*  Please send e-mail to yardleyb@us.ibm.com if you have
*  questions or comments.
*
*  Project Website:  TBD
*
* $Id: parse.c,v 1.8 2009/02/26 12:02:23 subrata_modak Exp $
*
*/
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <sys/stat.h>

#include "globals.h"
#include "threading.h"
#include "main.h"
#include "usage.h"
#include "sfunc.h"
#include "parse.h"

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, 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;
}

int make_assumptions(child_args_t * args)
{
	char TmpStr[80];
	struct stat stat_buf;
	int rv;

	if (!(args->flags & CLD_FLG_IOTYPS)) {
		/* use stat to get file properties, and use to set -I */
		rv = stat(args->device, &stat_buf);
		if (0 == rv) {
			if (IS_FILE(stat_buf.st_mode)) {
				strncat(args->argstr, "(-I f) ",
					(MAX_ARG_LEN - 1) -
					strlen(args->argstr));
				args->flags |= CLD_FLG_FILE;
			} else if (IS_BLK(stat_buf.st_mode)) {
				strncat(args->argstr, "(-I b) ",
					(MAX_ARG_LEN - 1) -
					strlen(args->argstr));
				args->flags |= CLD_FLG_BLK;
#ifndef WINDOWS
			} else if (S_ISCHR(stat_buf.st_mode)) {
				strncat(args->argstr, "(-I r) ",
					(MAX_ARG_LEN - 1) -
					strlen(args->argstr));
				args->flags |= CLD_FLG_RAW;
#endif
			}
		} else {
			pMsg(WARN, args,
			     "Can't get status on %s, defaulting to file, errno = %d\n",
			     args->device, GETLASTERROR());
			strncat(args->argstr, "(-I f) ",
				(MAX_ARG_LEN - 1) - strlen(args->argstr));
			args->flags |= CLD_FLG_FILE;
		}
	}
	if ((args->flags & CLD_FLG_WFSYNC) && (0 == args->sync_interval)) {
		pMsg(INFO, args,
		     "Sync interval set to zero, assuming interval of 1.\n");
		args->sync_interval = 1;
	}

	if (args->ltrsiz <= 0) {
		sprintf(TmpStr, "(-B %d) ", TRSIZ * BLK_SIZE);
		strncat(args->argstr, TmpStr,
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
		args->ltrsiz = TRSIZ;
		args->htrsiz = TRSIZ;
	}
	if (args->flags & CLD_FLG_LBA_RNG) {
		args->start_blk = args->start_lba / args->htrsiz;
		if (!(args->stop_lba < 0))
			args->stop_blk = args->stop_lba / args->htrsiz;
	}
	if (args->flags & CLD_FLG_BLK_RNG) {
		args->start_lba = args->start_blk * args->htrsiz;
		if (!(args->stop_blk < 0))
			args->stop_lba =
			    (args->stop_blk * args->htrsiz) + (args->htrsiz -
							       1);
	}
	/* if vsiz is still not set, try and get it from the file */
	if ((args->vsiz <= 0) && (args->flags & CLD_FLG_FILE)) {
		if (0 != get_file_size(args->device)) {	/* file size retrieved */
			args->vsiz = get_file_size(args->device);
		}
	}
	/* if vsiz is still not set, try and get it from the device */
	if ((args->vsiz <= 0) && !(args->flags & CLD_FLG_FILE)) {
		args->vsiz = get_vsiz(args->device);
	}
	/* if vsiz is still not set, set based on given range */
	if ((args->vsiz <= 0)
	    && (args->flags & (CLD_FLG_LBA_RNG | CLD_FLG_BLK_RNG))) {
		if (!(args->stop_lba < 0))
			args->vsiz = args->stop_lba + 1;
		else
			args->vsiz = args->start_lba + 1;
	}
	/* if vsiz is still not set, then set it to the default size */
	if (args->vsiz <= 0) {
		args->vsiz = VSIZ;
	}
	if (!(args->flags & CLD_FLG_VSIZ)) {
		sprintf(TmpStr, N_ASSUME, args->vsiz);
		strncat(args->argstr, TmpStr,
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
	}

	if (args->stop_lba == -1) {
		args->stop_lba = args->vsiz - 1;
	}
	if (args->stop_blk == -1) {
		args->stop_blk = (args->stop_lba / (OFF_T) args->htrsiz);
	}
	if (args->t_kids == 0) {
		sprintf(TmpStr, "(-K %d) ", KIDS);
		strncat(args->argstr, TmpStr,
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
		args->t_kids = KIDS;
	}
	if ((args->flags & (CLD_FLG_W | CLD_FLG_R)) == 0) {
		if (args->flags & CLD_FLG_DUTY) {	/* no read/write but duty cycle specified */
			if (args->rperc > 0) {
				args->flags |= CLD_FLG_R;
				strncat(args->argstr, "(-r) ",
					(MAX_ARG_LEN - 1) -
					strlen(args->argstr));
			}
			if (args->wperc > 0) {
				args->flags |= CLD_FLG_W;
				strncat(args->argstr, "(-w) ",
					(MAX_ARG_LEN - 1) -
					strlen(args->argstr));
			}
		} else {
			strncat(args->argstr, "(-r) ",
				(MAX_ARG_LEN - 1) - strlen(args->argstr));
			args->flags |= CLD_FLG_R;
		}
	}
	if (!(args->flags & CLD_FLG_PTYPS)) {
		strncat(args->argstr, "(-c) ",
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
		args->flags |= CLD_FLG_CPTYPE;
	}
	if (!(args->flags & CLD_FLG_SKTYPS)) {
		strncat(args->argstr, "(-p R) ",
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
		args->flags |= CLD_FLG_RANDOM;
	}
	if (!(args->flags & CLD_FLG_SKS)) {
		if (args->start_blk == args->stop_blk) {	/* diskcache test, w/ no seek count set */
			args->seeks = SEEKS;
		} else if (args->flags & (CLD_FLG_BLK_RNG | CLD_FLG_LBA_RNG)) {	/* range set, w/ no seek count */
			args->seeks = args->stop_blk - args->start_blk + 1;
		} else {
			/* if vsiz is available, calculated seeks are in terms of the largest transfer size */
			args->seeks =
			    (args->vsiz >
			     0) ? (args->vsiz / args->htrsiz) : SEEKS;
		}
		if ((args->flags & CLD_FLG_LINEAR) && (args->flags & CLD_FLG_R)
		    && (args->flags & CLD_FLG_W)) {
			args->seeks *= 2;
		}

		if (!(args->flags & CLD_FLG_TMD)) {
			sprintf(TmpStr, L_ASSUME, args->seeks);
			strncat(args->argstr, TmpStr,
				(MAX_ARG_LEN - 1) - strlen(args->argstr));
		}
	}
	if (!(args->flags & (CLD_FLG_SKS | CLD_FLG_TMD))
	    || ((args->flags & CLD_FLG_CYC)
		&& !(args->flags & (CLD_FLG_SKS | CLD_FLG_TMD)))) {
		args->flags |= CLD_FLG_SKS;
	}
	if (args->flags & (CLD_FLG_LINEAR)) {
		if (!(args->flags & (CLD_FLG_LUNU | CLD_FLG_LUND))) {
			strncat(args->argstr, "(-p u) ",
				(MAX_ARG_LEN - 1) - strlen(args->argstr));
			args->flags |= CLD_FLG_LUNU;
		}
	}
	normalize_percs(args);
	if (!(args->flags & CLD_FLG_DUTY) && (args->flags & CLD_FLG_RANDOM)
	    && !(args->flags & CLD_FLG_NTRLVD)) {
		sprintf(TmpStr, "(-D %d:%d) ", args->rperc, args->wperc);
		strncat(args->argstr, TmpStr,
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
		args->flags |= CLD_FLG_DUTY;
	}
	if ((args->delayTimeMin == 0) && (args->delayTimeMax == 0)
	    && (args->ioTimeout == DEFAULT_IO_TIMEOUT)) {
		strncat(args->argstr, "(-t 0:2m) ",
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
	}
	if (!(args->flags & CLD_FLG_OFFSET)) {
		strncat(args->argstr, "(-o 0) ",
			(MAX_ARG_LEN - 1) - strlen(args->argstr));
	}

	return 0;
}

/*
 * checks validity of data after parsing
 * args and make assumtions. returns 0 on
 * success and -1 on failure.
 */
int check_conclusions(child_args_t * args)
{
	extern unsigned long glb_flags;
	struct stat stat_buf;
	int rv;

	if ((args->flags & CLD_FLG_DUTY)
	    && ((args->flags & CLD_FLG_LINEAR)
		|| (args->flags & CLD_FLG_NTRLVD))) {
		pMsg(WARN, args,
		     "Duty cycle testing is supported for random (-pR) tests only.\n");
		return (-1);
	}
	if ((args->flags & CLD_FLG_BLK_RNG) && (args->flags & CLD_FLG_RTRSIZ)) {
		pMsg(WARN, args,
		     "Can't have unfixed block sizes and specify seek range in terms of blocks.\n");
		return (-1);
	}
	if ((args->vsiz < 0) || (args->ltrsiz < 1) || (args->htrsiz < 1)) {
		pMsg(WARN, args,
		     "Bounds exceeded for transfer size and/or volume size.\n");
		pMsg(WARN, args, MAXTRSIZ, (args->htrsiz * BLK_SIZE),
		     args->vsiz);
		return (-1);
	}
	if (args->htrsiz < args->ltrsiz) {
		pMsg(ERR, args,
		     "Min transfer size, %lu, greater then Max transfer size, %lu.\n",
		     args->ltrsiz, args->htrsiz);
		return (-1);
	}
	if (args->vsiz < (args->stop_lba - args->start_lba + 1)) {
		pMsg(ERR, args, "Volume stop block/lba exceeds volume size.\n");
		return (-1);
	}
	if (args->vsiz < args->htrsiz) {
		pMsg(WARN, args, VSIZETS, args->vsiz, args->htrsiz);
		return (-1);
	}
	if ((args->flags & CLD_FLG_TMD) == 0 && (args->seeks <= 0)) {
		pMsg(WARN, args, TSEEK, args->seeks);
		return (-1);
	}
	if ((args->flags & CLD_FLG_SKS) && (args->t_kids > args->seeks)) {
		pMsg(WARN, args,
		     "Can't have more children then max number of seeks, use -K/-L to adjust.\n");
		return (-1);
	}
	if ((args->start_blk > args->vsiz)
	    && !(args->flags & (CLD_FLG_BLK_RNG | CLD_FLG_LBA_RNG))) {
		pMsg(WARN, args, STBGTTLBA, args->start_blk,
		     (args->vsiz / args->htrsiz));
		return (-1);
	}
	if ((args->stop_blk > args->vsiz)
	    && !(args->flags & (CLD_FLG_BLK_RNG | CLD_FLG_LBA_RNG))) {
		pMsg(WARN, args, SBGTTLBA, args->stop_blk,
		     (args->vsiz / args->htrsiz));
		return (-1);
	}
	if ((args->start_lba > args->vsiz)
	    && !(args->flags & (CLD_FLG_BLK_RNG | CLD_FLG_LBA_RNG))) {
		pMsg(WARN, args, STLBAGTLBA, args->start_lba, args->vsiz);
		return (-1);
	}
	if ((args->stop_lba > args->vsiz)
	    && !(args->flags & (CLD_FLG_BLK_RNG | CLD_FLG_LBA_RNG))) {
		pMsg(WARN, args, SLBAGTLBA, args->stop_lba, args->vsiz);
		return (-1);
	}
	if (args->start_blk > args->stop_blk) {
		pMsg(WARN, args, SBRSB, args->stop_blk, args->start_blk);
		return (-1);
	}
	if (args->start_lba > args->stop_lba) {
		pMsg(ERR, args, SLBARSLBA, args->stop_lba, args->start_lba);
		return (-1);
	}
	if ((args->flags & CLD_FLG_LBA_RNG) && (args->flags & CLD_FLG_BLK_RNG)) {
		pMsg(ERR, args,
		     "Can't specify range in both block and LBA, use -s or -S.\n");
		return (-1);
	}

	/* use stat to get file properties, and test then agains specified -I */
	rv = stat(args->device, &stat_buf);
	if (0 == rv) {		/* no error on call to stat, compare against -I option */
		/* files are usually file type */
		if ((args->flags & CLD_FLG_FILE) && !IS_FILE(stat_buf.st_mode)) {
			pMsg(ERR, args,
			     "Can't open non-file filespec with file device type, -If.\n");
			return (-1);
		}
		/* block devices, are usually block type */
		if ((args->flags & CLD_FLG_BLK) && !IS_BLK(stat_buf.st_mode)) {
			pMsg(ERR, args,
			     "Can't open non-block filespec with block device type, -Ib.\n");
			return (-1);
		}
#ifndef WINDOWS
		/* raw devices, are usually character type */
		if ((args->flags & CLD_FLG_RAW) && !S_ISCHR(stat_buf.st_mode)) {
			pMsg(ERR, args,
			     "Can't open non-raw filespec with raw device type, -Ir.\n");
			return (-1);
		}
#else
		if (args->flags & CLD_FLG_RAW) {
			pMsg(ERR, args,
			     "RAW IO type not supported in Windows, use direct IO instead.\n");
			return (-1);
		}
#endif
#ifdef _DEBUG
	} else {
		PDBG1(DBUG, args,
		      "Can't get status on %s, assuming a new file, errno = %d\n",
		      args->device, GETLASTERROR());
#endif
	}

	if ((args->hbeat > 0) && (args->flags & CLD_FLG_TMD)
	    && (args->hbeat > args->run_time)) {
		pMsg(ERR, args,
		     "Heartbeat should be at least equal to runtime, use -h/-T to adjust.\n");
		return (-1);
	}
	if ((args->hbeat > 0) && !(args->flags & CLD_FLG_PRFTYPS)) {
		pMsg(ERR, args,
		     "At least one performance option, -P, must be specified when using -h.\n");
		return (-1);
	}
	if ((args->flags & CLD_FLG_W) && !(args->flags & CLD_FLG_R)
	    && (args->flags & CLD_FLG_CMPR)) {
		pMsg(ERR, args, "Write only, ignoring option -E.\n");
	}
	if ((args->flags & CLD_FLG_TMD) && (args->flags & CLD_FLG_SKS)) {
		pMsg(ERR, args,
		     "Can't specify both -L and -T they are mutually exclusive.\n");
		return (-1);
	}
	if (((args->flags & CLD_FLG_R) && !(args->flags & CLD_FLG_W))
	    && (args->flags & CLD_FLG_ERR_MARK)) {
		pMsg(ERR, args,
		     "Can't specify mark on error, -Am, in read only mode.\n");
		return (-1);
	}
	if (!(args->flags & CLD_FLG_ALLDIE) && (args->flags & CLD_FLG_ERR_MARK)) {
		pMsg(ERR, args,
		     "Can't specify mark on error, -Am, when continue on error is set.\n");
		return (-1);
	}
	if ((glb_flags & GLB_FLG_KILL) && !(args->flags & CLD_FLG_ALLDIE)) {
		pMsg(ERR, args,
		     "Can't specify global kill, -Ag, when continue on error is set, -Ac.\n");
		return (-1);
	}
	if ((args->flags & CLD_FLG_LINEAR) && !(args->flags & CLD_FLG_NTRLVD)
	    && (args->flags & CLD_FLG_TMD)) {
		pMsg(ERR, args, "Linear read / write test can not be timed.\n");
		return (-1);
	}
	if ((args->flags & CLD_FLG_CMPR)
	    && (args->cmp_lng > (args->ltrsiz * BLK_SIZE))) {
		pMsg(ERR, args,
		     "Compare length, %lu, is greater then transfer size, %lu\n",
		     args->cmp_lng, args->ltrsiz * BLK_SIZE);
		return (-1);
	}
	if ((args->flags & CLD_FLG_OFFSET) && (args->offset > args->stop_lba)) {
		pMsg(ERR, args, LBAOFFGSLBA, args->offset, args->stop_lba);
		return (-1);
	}
	if ((args->flags & CLD_FLG_OFFSET)
	    && ((args->offset + args->ltrsiz - 1) > args->stop_lba)) {
		pMsg(ERR, args, LBAOTSGSLBA, args->offset, args->ltrsiz,
		     args->stop_lba);
		return (-1);
	}
	return 0;
}