testcases/kernel/fs/doio/iogen.c

/*
 * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Further, this software is distributed without any warranty that it is
 * free of the rightful claim of any third person regarding infringement
 * or the like.  Any license provided herein, whether implied or
 * otherwise, applies only to this software file.  Patent licenses, if
 * any, provided herein do not apply to combinations of this program with
 * other software, or any other product whatsoever.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 * Mountain View, CA  94043, or:
 *
 * http://www.sgi.com
 *
 * For further information regarding this notice, see:
 *
 * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
 */
/*
 * iogen - a tool for generating file/sds io for a doio process
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <time.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#ifdef CRAY
#include <sys/file.h>
#include <sys/iosw.h>
#include <sys/listio.h>
#endif
#ifdef sgi
#include <sys/statvfs.h>
#include <sys/fs/xfs_itable.h>
#endif

#ifdef CRAY
#include "libkern.h"
#endif
#include "doio.h"
#include "bytes_by_prefix.h"
#include "string_to_tokens.h"
#include "open_flags.h"
#include "random_range.h"

#ifndef PATH_MAX
#define	PATH_MAX 512		/* ??? */
#endif

#ifndef BSIZE
#ifdef linux
#define BSIZE DEV_BSIZE
#else
#define BSIZE 512
#endif
#endif

#define RAW_IO(_flags_)	((_flags_) & (O_RAW | O_SSD))

#ifndef __linux__
extern char *sys_errlist[];
#endif
#define SYSERR	strerror(errno)

/*
 * Structure for retaining test file information
 */

struct file_info {
	char f_path[MAX_FNAME_LENGTH + 1];	/* file name (full path)    */
	int f_length;		/* length in bytes                      */
	int f_iou;		/* file iounit                          */
	int f_riou;		/* file raw iounit (for O_RAW/O_SSD)    */
	int f_dalign;		/* direct I/O alignment                 */
	int f_nextoff;		/* offset of end of last io operation   */
	int f_type;		/* file type S_IFREG, etc...            */
	int f_lastoffset;	/* offset of last io operation          */
	int f_lastlength;	/* length of last io operation          */
};

/*
 * Simple structure for associating strings with values - useful for converting
 * cmdline args to internal values, as well as printing internal values in
 * a human readable form.
 */

struct strmap {
	char *m_string;
	int m_value;
	int m_flags;
};

void startup_info(FILE * stream, int seed);
int init_output(void);
int form_iorequest(struct io_req *req);
int get_file_info(struct file_info *rec);
int create_file(char *path, int nbytes);
int str_to_value(struct strmap *map, char *str);
struct strmap *str_lookup(struct strmap *map, char *str);
char *value_to_string(struct strmap *map, int val);
int parse_cmdline(int argc, char **argv, char *opts);
int help(FILE * stream);
int usage(FILE * stream);

/*
 * Declare cmdline option flags/variables initialized in parse_cmdline()
 */

#define OPTS	"a:dhf:i:L:m:op:qr:s:t:T:O:N:"

int a_opt = 0;			/* async io comp. types supplied            */
int o_opt = 0;			/* form overlapping requests                */
int f_opt = 0;			/* test flags                               */
int i_opt = 0;			/* iterations - 0 implies infinite          */
int L_opt = 0;			/* listio min-max nstrides & nents          */
int m_opt = 0;			/* offset mode                              */
int O_opt = 0;			/* file creation Open flags                 */
int p_opt = 0;			/* output pipe - default is stdout          */
int r_opt = 0;			/* specify raw io multiple instead of       */
				/* getting it from the mounted on device.   */
				/* Only applies to regular files.           */
int s_opt = 0;			/* syscalls                                 */
int t_opt = 0;			/* min transfer size (bytes)                */
int T_opt = 0;			/* max transfer size (bytes)                */
int q_opt = 0;			/* quiet operation on startup               */
char TagName[40];		/* name of this iogen (see Monster)         */
struct strmap *Offset_Mode;	/* M_SEQUENTIAL, M_RANDOM, etc.             */
int Iterations;			/* # requests to generate (0 --> infinite)  */
int Time_Mode = 0;		/* non-zero if Iterations is in seconds     */
				/* (ie. -i arg was suffixed with 's')       */
char *Outpipe;			/* Pipe to write output to if p_opt         */
int Mintrans;			/* min io transfer size                     */
int Maxtrans;			/* max io transfer size                     */
int Rawmult;			/* raw/ssd io multiple (from -r)            */
int Minstrides;			/* min # of listio strides per request      */
int Maxstrides;			/* max # of listio strides per request      */
int Oflags;			/* open(2) flags for creating files         */
int Ocbits;			/* open(2) cbits for creating files         */
int Ocblks;			/* open(2) cblks for creating files         */
int Orealtime = 0;		/* flag set for -O REALTIME                 */
int Oextsize = 0;		/* real-time extent size                    */
int Oreserve = 1;		/* flag for -O [no]reserve                  */
int Oallocate = 0;		/* flag for -O allocate                     */
int Owrite = 1;			/* flag for -O nowrite                      */

int Nfiles = 0;			/* # files on cmdline                       */
struct file_info *File_List;	/* info about each file                     */
int Nflags = 0;			/* # flags on cmdline                       */
struct strmap *Flag_List[128];	/* flags selected from cmdline              */
int Nsyscalls = 0;		/* # syscalls on cmdline                    */
struct strmap *Syscall_List[128];	/* syscalls selected on cmdline          */
int Fileio = 0;			/* flag indicating that a file              */
				/* io syscall has been chosen.              */
int Naio_Strat_Types = 0;	/* # async io completion types              */
struct strmap *Aio_Strat_List[128];	/* Async io completion types           */

/*
 * Map async io completion modes (-a args) names to values.  Macros are
 * defined in doio.h.
 */

struct strmap Aio_Strat_Map[] = {
#ifndef linux
	{"poll", A_POLL},
	{"signal", A_SIGNAL},
#else
	{"none", 0},
#endif /* !linux */
#ifdef CRAY
#if _UMK || RELEASE_LEVEL >= 8000
	{"recall", A_RECALL},
#endif

#ifdef RECALL_SIZEOF
	{"recalla", A_RECALLA},
#endif
	{"recalls", A_RECALLS},
#endif /* CRAY */

#ifdef sgi
	{"suspend", A_SUSPEND},
	{"callback", A_CALLBACK},
#endif
	{NULL, -1}
};

/*
 * Offset_Mode #defines
 */

#define M_RANDOM    	1
#define M_SEQUENTIAL	2
#define M_REVERSE   	3

/*
 * Map offset mode (-m args) names to values
 */

struct strmap Omode_Map[] = {
	{"random", M_RANDOM},
	{"sequential", M_SEQUENTIAL},
	{"reverse", M_REVERSE},
	{NULL, -1}
};

/*
 * Map syscall names (-s args) to values - macros are defined in doio.h.
 */
#define	SY_ASYNC	00001
#define	SY_WRITE	00002
#define	SY_SDS		00010
#define	SY_LISTIO	00020
#define	SY_NENT		00100	/* multi entry vs multi stride >>> */

struct strmap Syscall_Map[] = {
	{"read", READ, 0},
	{"write", WRITE, SY_WRITE},
#ifdef CRAY
	{"reada", READA, SY_ASYNC},
	{"writea", WRITEA, SY_WRITE | SY_ASYNC},
#ifndef _CRAYMPP
	{"ssread", SSREAD, SY_SDS},
	{"sswrite", SSWRITE, SY_WRITE | SY_SDS},
#endif
	{"listio", LISTIO, SY_ASYNC},

	/* listio as 4 system calls */
	{"lread", LREAD, 0},
	{"lreada", LREADA, SY_ASYNC},
	{"lwrite", LWRITE, SY_WRITE},
	{"lwritea", LWRITEA, SY_WRITE | SY_ASYNC},

	/* listio with nstrides > 1 */
	{"lsread", LSREAD, 0},
	{"lsreada", LSREADA, SY_ASYNC},
	{"lswrite", LSWRITE, SY_WRITE},
	{"lswritea", LSWRITEA, SY_WRITE | SY_ASYNC},

	/* listio with nents > 1 */
	{"leread", LEREAD, 0 | SY_NENT},
	{"lereada", LEREADA, SY_ASYNC | SY_NENT},
	{"lewrite", LEWRITE, SY_WRITE | SY_NENT},
	{"lewritea", LEWRITEA, SY_WRITE | SY_ASYNC | SY_NENT},

	/* listio with nents > 1 & nstrides > 1 */

	/* all listio system calls under one name */
	{"listio+", LREAD, 0},
	{"listio+", LREADA, SY_ASYNC},
	{"listio+", LWRITE, SY_WRITE},
	{"listio+", LWRITEA, SY_WRITE | SY_ASYNC},
	{"listio+", LSREAD, 0},
	{"listio+", LSREADA, SY_ASYNC},
	{"listio+", LSWRITE, SY_WRITE},
	{"listio+", LSWRITEA, SY_WRITE | SY_ASYNC},
	{"listio+", LEREAD, 0 | SY_NENT},
	{"listio+", LEREADA, SY_ASYNC | SY_NENT},
	{"listio+", LEWRITE, SY_WRITE | SY_NENT},
	{"listio+", LEWRITEA, SY_WRITE | SY_ASYNC | SY_NENT},
#endif

#ifdef sgi
	{"pread", PREAD},
	{"pwrite", PWRITE, SY_WRITE},
	{"aread", AREAD, SY_ASYNC},
	{"awrite", AWRITE, SY_WRITE | SY_ASYNC},
#if 0
	/* not written yet */
	{"llread", LLREAD, 0},
	{"llaread", LLAREAD, SY_ASYNC},
	{"llwrite", LLWRITE, 0},
	{"llawrite", LLAWRITE, SY_ASYNC},
#endif
	{"resvsp", RESVSP, SY_WRITE},
	{"unresvsp", UNRESVSP, SY_WRITE},
	{"reserve", RESVSP, SY_WRITE},
	{"unreserve", UNRESVSP, SY_WRITE},
	{"ffsync", DFFSYNC, SY_WRITE},
#endif /* SGI */

#ifndef CRAY
	{"readv", READV},
	{"writev", WRITEV, SY_WRITE},
	{"mmread", MMAPR},
	{"mmwrite", MMAPW, SY_WRITE},
	{"fsync2", FSYNC2, SY_WRITE},
	{"fdatasync", FDATASYNC, SY_WRITE},
#endif

	{NULL, -1}
};

/*
 * Map open flags (-f args) to values
 */
#define	FLG_RAW		00001

struct strmap Flag_Map[] = {
	{"buffered", 0, 0},
	{"sync", O_SYNC, 0},
#ifdef CRAY
	{"raw", O_RAW, FLG_RAW},
	{"raw+wf", O_RAW | O_WELLFORMED, FLG_RAW},
	{"raw+wf+ldraw", O_RAW | O_WELLFORMED | O_LDRAW, FLG_RAW},
	{"raw+wf+ldraw+sync", O_RAW | O_WELLFORMED | O_LDRAW | O_SYNC, FLG_RAW},
#ifdef O_SSD
	{"ssd", O_SSD, FLG_RAW},
#endif
#ifdef O_LDRAW
	{"ldraw", O_LDRAW, 0},
#endif
#ifdef O_PARALLEL
	{"parallel", O_PARALLEL | O_RAW | O_WELLFORMED,
	 FLG_RAW},
	{"parallel+sync", O_PARALLEL | O_RAW | O_WELLFORMED | O_SYNC,
	 FLG_RAW},
	{"parallel+ldraw", O_PARALLEL | O_RAW | O_WELLFORMED | O_LDRAW,
	 FLG_RAW},
	{"parallel+ldraw+sync",
	 O_PARALLEL | O_RAW | O_WELLFORMED | O_LDRAW | O_SYNC,
	 FLG_RAW},
#endif
#endif /* CRAY */

#ifdef sgi
	{"direct", O_DIRECT, FLG_RAW},
	{"dsync", O_DSYNC},	/* affects writes */
	{"rsync", O_RSYNC},	/* affects reads */
	{"rsync+dsync", O_RSYNC | O_DSYNC},
#endif
	{NULL, -1}
};

/*
 * Map file types to strings
 */

struct strmap Ftype_Map[] = {
	{"regular", S_IFREG},
	{"blk-spec", S_IFBLK},
	{"chr-spec", S_IFCHR},
	{NULL, 0}
};

/*
 * Misc declarations
 */

int Sds_Avail;

char Byte_Patterns[26] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
	'Y', 'Z'
};

int main(int argc, char **argv)
{
	int rseed, outfd, infinite;
	time_t start_time;
	struct io_req req;

	umask(0);

#ifdef CRAY
	Sds_Avail = sysconf(_SC_CRAY_SDS);
#else
	Sds_Avail = 0;
#endif

	TagName[0] = '\0';
	parse_cmdline(argc, argv, OPTS);

	/*
	 * Initialize output descriptor.
	 */
	if (!p_opt) {
		outfd = 1;
	} else {
		outfd = init_output();
	}

	rseed = getpid();
	random_range_seed(rseed);	/* initialize random number generator */

	/*
	 * Print out startup information, unless we're running in quiet mode
	 */
	if (!q_opt)
		startup_info(stderr, rseed);
	{
		struct timeval ts;
		gettimeofday(&ts, NULL);
		start_time = ts.tv_sec;
	}
	/*
	 * While iterations (or forever if Iterations == 0) - compute an
	 * io request, and write the structure to the output descriptor
	 */

	infinite = !Iterations;
	struct timeval ts;
	gettimeofday(&ts, NULL);
	while (infinite ||
	       (!Time_Mode && Iterations--) ||
	       (Time_Mode && (ts.tv_sec - start_time <= Iterations))) {
		gettimeofday(&ts, NULL);
		memset(&req, 0, sizeof(struct io_req));
		if (form_iorequest(&req) == -1) {
			fprintf(stderr, "iogen%s:  form_iorequest() failed\n",
				TagName);
			continue;
		}

		req.r_magic = DOIO_MAGIC;
		if (write(outfd, (char *)&req, sizeof(req)) == -1)
			perror("Warning: Could not write");
	}

	exit(0);

}				/* main */

void startup_info(FILE * stream, int seed)
{
	char *value_to_string(), *type;
	int i;

	fprintf(stream, "\n");
	fprintf(stream, "iogen%s starting up with the following:\n", TagName);
	fprintf(stream, "\n");

	fprintf(stream, "Out-pipe:              %s\n",
		p_opt ? Outpipe : "stdout");

	if (Iterations) {
		fprintf(stream, "Iterations:            %d", Iterations);
		if (Time_Mode)
			fprintf(stream, " seconds");

		fprintf(stream, "\n");
	} else {
		fprintf(stream, "Iterations:            Infinite\n");
	}

	fprintf(stream, "Seed:                  %d\n", seed);

	fprintf(stream, "Offset-Mode:           %s\n", Offset_Mode->m_string);

	fprintf(stream, "Overlap Flag:          %s\n", o_opt ? "on" : "off");

	fprintf(stream,
		"Mintrans:              %-11d (%d blocks)\n",
		Mintrans, (Mintrans + BSIZE - 1) / BSIZE);

	fprintf(stream,
		"Maxtrans:              %-11d (%d blocks)\n",
		Maxtrans, (Maxtrans + BSIZE - 1) / BSIZE);

	if (!r_opt)
		fprintf(stream,
			"O_RAW/O_SSD Multiple:  (Determined by device)\n");
	else
		fprintf(stream,
			"O_RAW/O_SSD Multiple:  %-11d (%d blocks)\n",
			Rawmult, (Rawmult + BSIZE - 1) / BSIZE);

	fprintf(stream, "Syscalls:              ");
	for (i = 0; i < Nsyscalls; i++)
		fprintf(stream, "%s ", Syscall_List[i]->m_string);
	fprintf(stream, "\n");

	fprintf(stream, "Aio completion types:  ");
	for (i = 0; i < Naio_Strat_Types; i++)
		fprintf(stream, "%s ", Aio_Strat_List[i]->m_string);
	fprintf(stream, "\n");

	if (Fileio) {
		fprintf(stream, "Flags:                 ");
		for (i = 0; i < Nflags; i++)
			fprintf(stream, "%s ", Flag_List[i]->m_string);

		fprintf(stream, "\n");
		fprintf(stream, "\n");
		fprintf(stream, "Test Files:  \n");
		fprintf(stream, "\n");
		fprintf(stream,
			"Path                                          Length    iou   raw iou file\n");
		fprintf(stream,
			"                                              (bytes) (bytes) (bytes) type\n");
		fprintf(stream,
			"-----------------------------------------------------------------------------\n");

		for (i = 0; i < Nfiles; i++) {
			type = value_to_string(Ftype_Map, File_List[i].f_type);
			fprintf(stream, "%-40s %12d %7d %7d %s\n",
				File_List[i].f_path, File_List[i].f_length,
				File_List[i].f_iou, File_List[i].f_riou, type);
		}
	}
}

/*
 * Initialize output descriptor.  If going to stdout, its easy,
 * otherwise, attempt to create a FIFO on path Outpipe.  Exit with an
 * error code if this cannot be done.
 */
int init_output(void)
{
	int outfd;
	struct stat sbuf;

	if (stat(Outpipe, &sbuf) == -1) {
		if (errno == ENOENT) {
			if (mkfifo(Outpipe, 0666) == -1) {
				fprintf(stderr,
					"iogen%s:  Could not mkfifo %s:  %s\n",
					TagName, Outpipe, SYSERR);
				exit(2);
			}
		} else {
			fprintf(stderr,
				"iogen%s:  Could not stat outpipe %s:  %s\n",
				TagName, Outpipe, SYSERR);
			exit(2);
		}
	} else {
		if (!S_ISFIFO(sbuf.st_mode)) {
			fprintf(stderr,
				"iogen%s:  Output file %s exists, but is not a FIFO\n",
				TagName, Outpipe);
			exit(2);
		}
	}

	if ((outfd = open(Outpipe, O_RDWR)) == -1) {
		fprintf(stderr,
			"iogen%s:  Couldn't open outpipe %s with flags O_RDWR: %s\n",
			TagName, Outpipe, SYSERR);
		exit(2);
	}

	return (outfd);
}

/*
 * Main io generation function.  form_iorequest() selects a system call to
 * do based on cmdline arguments, and proceeds to select parameters for that
 * system call.
 *
 * Returns 0 if req is filled in with a complete doio request, otherwise
 * returns -1.
 */

int form_iorequest(struct io_req *req)
{
	int mult, offset = 0, length = 0, slength;
	int minlength, maxlength, laststart, lastend;
	int minoffset, maxoffset;
	int maxstride, nstrides;
	char pattern, *errp;
	struct strmap *flags, *sc, *aio_strat;
	struct file_info *fptr;
#ifdef CRAY
	int opcode, cmd;
#endif

	/*
	 * Choose system call, flags, and file
	 */

	sc = Syscall_List[random_range(0, Nsyscalls - 1, 1, NULL)];
	req->r_type = sc->m_value;

#ifdef CRAY
	if (sc->m_value == LISTIO) {
		opcode = random_range(0, 1, 1, NULL) ? LO_READ : LO_WRITE;
		cmd = random_range(0, 1, 1, NULL) ? LC_START : LC_WAIT;
	}
#endif

	if (sc->m_flags & SY_WRITE)
		pattern =
		    Byte_Patterns[random_range
				  (0, sizeof(Byte_Patterns) - 1, 1, NULL)];
	else
		pattern = 0;

#if CRAY
	/*
	 * If sds io, simply choose a length (possibly pattern) and return
	 */

	if (sc->m_flags & SY_SDS) {
		req->r_data.ssread.r_nbytes =
		    random_range(Mintrans, Maxtrans, BSIZE, NULL);
		if (sc->m_flags & SY_WRITE)
			req->r_data.sswrite.r_pattern = pattern;

		return 0;
	}
#endif

	/*
	 * otherwise, we're doing file io.  Choose starting offset, length,
	 * open flags, and possibly a pattern (for write/writea).
	 */

	fptr = &File_List[random_range(0, Nfiles - 1, 1, NULL)];
	flags = Flag_List[random_range(0, Nflags - 1, 1, NULL)];

	/*
	 * Choose offset/length multiple.  IO going to a device, or regular
	 * IO that is O_RAW or O_SSD must be aligned on the file r_iou.  Otherwise
	 * it must be aligned on the regular iou (normally 1).
	 */

	if (fptr->f_type == S_IFREG && (flags->m_flags & FLG_RAW))
		mult = fptr->f_riou;
	else
		mult = fptr->f_iou;

	/*
	 * Choose offset and length.  Both must be a multiple of mult
	 */

	/*
	 * Choose length first - it must be a multiple of mult
	 */

	laststart = fptr->f_lastoffset;
	lastend = fptr->f_lastoffset + fptr->f_lastlength - 1;

	minlength = (Mintrans > mult) ? Mintrans : mult;

	switch (Offset_Mode->m_value) {
	case M_SEQUENTIAL:
		if (o_opt && lastend > laststart)
			offset = random_range(laststart, lastend, 1, NULL);
		else
			offset = lastend + 1;
		if (offset && (offset % mult))
			offset += mult - (offset % mult);

		if (minlength > fptr->f_length - offset)
			offset = 0;

		maxlength = fptr->f_length - offset;
		if (maxlength > Maxtrans)
			maxlength = Maxtrans;

		length = random_range(minlength, maxlength, mult, &errp);
		if (errp != NULL) {
			fprintf(stderr,
				"iogen%s:  random_range(%d, %d, %d) failed\n",
				TagName, minlength, maxlength, mult);
			return -1;
		}

		break;

	case M_REVERSE:
		maxlength = laststart;

		if (maxlength > Maxtrans)
			maxlength = Maxtrans;

		if (minlength > maxlength) {
			laststart = fptr->f_length;
			lastend = fptr->f_length;
			maxlength = Maxtrans;
		}

		length = random_range(minlength, maxlength, mult, &errp);
		if (errp != NULL) {
			fprintf(stderr,
				"iogen%s:  random_range(%d, %d, %d) failed\n",
				TagName, minlength, maxlength, mult);
			return -1;
		}

		offset = laststart - length;

		if (o_opt && lastend > laststart)
			offset += random_range(1, lastend - laststart, 1, NULL);

		if (offset && (offset % mult))
			offset -= offset % mult;

		break;

	case M_RANDOM:
		length = random_range(Mintrans, Maxtrans, mult, NULL);

		if (o_opt && lastend > laststart) {
			minoffset = laststart - length + 1;
			if (minoffset < 0) {
				minoffset = 0;
			}

			if (lastend + length > fptr->f_length) {
				maxoffset = fptr->f_length - length;
			} else {
				maxoffset = lastend;
			}
		} else {
			minoffset = 0;
			maxoffset = fptr->f_length - length;
		}

		if (minoffset < 0)
			minoffset = 0;

		offset = random_range(minoffset, maxoffset, mult, &errp);
		if (errp != NULL) {
			fprintf(stderr,
				"iogen%s:  random_range(%d, %d, %d) failed\n",
				TagName, minoffset, maxoffset, mult);
			return -1;
		}
	}

	fptr->f_lastoffset = offset;
	fptr->f_lastlength = length;

	/*
	 * Choose an async io completion strategy if necessary
	 */
	if (sc->m_flags & SY_ASYNC)
		aio_strat = Aio_Strat_List[random_range(0, Naio_Strat_Types - 1,
							1, NULL)];
	else
		aio_strat = NULL;

	/*
	 * fill in specific syscall record data
	 */
	switch (sc->m_value) {
	case READ:
	case READA:
		strcpy(req->r_data.read.r_file, fptr->f_path);
		req->r_data.read.r_oflags = O_RDONLY | flags->m_value;
		req->r_data.read.r_offset = offset;
		req->r_data.read.r_nbytes = length;
		req->r_data.read.r_uflags =
		    (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
		req->r_data.read.r_aio_strat =
		    (aio_strat == NULL) ? 0 : aio_strat->m_value;
		req->r_data.read.r_nstrides = 1;
		req->r_data.read.r_nent = 1;
		break;

	case WRITE:
	case WRITEA:
		strcpy(req->r_data.write.r_file, fptr->f_path);
		req->r_data.write.r_oflags = O_WRONLY | flags->m_value;
		req->r_data.write.r_offset = offset;
		req->r_data.write.r_nbytes = length;
		req->r_data.write.r_pattern = pattern;
		req->r_data.write.r_uflags =
		    (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
		req->r_data.write.r_aio_strat =
		    (aio_strat == NULL) ? 0 : aio_strat->m_value;
		req->r_data.write.r_nstrides = 1;
		req->r_data.write.r_nent = 1;
		break;

	case READV:
	case AREAD:
	case PREAD:
	case WRITEV:
	case AWRITE:
	case PWRITE:

	case LREAD:
	case LREADA:
	case LWRITE:
	case LWRITEA:

	case RESVSP:
	case UNRESVSP:
	case DFFSYNC:
	case FSYNC2:
	case FDATASYNC:

		strcpy(req->r_data.io.r_file, fptr->f_path);
		req->r_data.io.r_oflags =
		    ((sc->m_flags & SY_WRITE) ? O_WRONLY : O_RDONLY) | flags->
		    m_value;
		req->r_data.io.r_offset = offset;
		req->r_data.io.r_nbytes = length;
		req->r_data.io.r_pattern = pattern;
		req->r_data.io.r_uflags =
		    (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
		req->r_data.io.r_aio_strat =
		    (aio_strat == NULL) ? 0 : aio_strat->m_value;
		req->r_data.io.r_nstrides = 1;
		req->r_data.io.r_nent = 1;
		break;

	case MMAPR:
	case MMAPW:
		strcpy(req->r_data.io.r_file, fptr->f_path);
		/* a subtle "feature" of mmap: a write-map requires
		   the file open read/write */
		req->r_data.io.r_oflags =
		    ((sc->m_flags & SY_WRITE) ? O_RDWR : O_RDONLY) | flags->
		    m_value;
		req->r_data.io.r_offset = offset;
		req->r_data.io.r_nbytes = length;
		req->r_data.io.r_pattern = pattern;
		req->r_data.io.r_uflags =
		    (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
		req->r_data.io.r_aio_strat =
		    (aio_strat == NULL) ? 0 : aio_strat->m_value;
		req->r_data.io.r_nstrides = 1;
		req->r_data.io.r_nent = 1;
		break;

	case LSREAD:
	case LSREADA:
	case LEREAD:
	case LEREADA:
	case LSWRITE:
	case LSWRITEA:
	case LEWRITE:
	case LEWRITEA:
		/* multi-strided */
		strcpy(req->r_data.io.r_file, fptr->f_path);
		req->r_data.io.r_oflags =
		    ((sc->m_flags & SY_WRITE) ? O_WRONLY : O_RDONLY) | flags->
		    m_value;
		req->r_data.io.r_offset = offset;
		req->r_data.io.r_uflags =
		    (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
		req->r_data.io.r_aio_strat =
		    (aio_strat == NULL) ? 0 : aio_strat->m_value;
		req->r_data.io.r_pattern = pattern;

		/* multi-strided request...
		 *  random number of strides (1...MaxStrides)
		 *  length of stride must be > minlength
		 *  length of stride must be % mult
		 *
		 * maxstrides = min(length / mult, overall.max#strides)
		 * nstrides = random #
		 * while (length / nstrides < minlength)
		 *      nstrides = new random #
		 */
		maxstride = length / mult;
		if (maxstride > Maxstrides)
			maxstride = Maxstrides;

		if (!Minstrides)
			Minstrides = 1;
		nstrides = random_range(Minstrides, maxstride, 1, &errp);
		if (errp != NULL) {
			fprintf(stderr,
				"iogen%s:  random_range(%d, %d, %d) failed\n",
				TagName, Minstrides, maxstride, 1);
			return -1;
		}

		slength = length / nstrides;
		if (slength % mult != 0) {
			if (mult > slength) {
				slength = mult;
			} else {
				slength -= slength % mult;
			}
			nstrides = length / slength;
			if (nstrides > Maxstrides)
				nstrides = Maxstrides;
		}

		req->r_data.io.r_nbytes = slength;
		if (sc->m_flags & SY_NENT) {
			req->r_data.io.r_nstrides = 1;
			req->r_data.io.r_nent = nstrides;
		} else {
			req->r_data.io.r_nstrides = nstrides;
			req->r_data.io.r_nent = 1;
		}
		break;

	case LISTIO:
#ifdef CRAY
		strcpy(req->r_data.listio.r_file, fptr->f_path);
		req->r_data.listio.r_offset = offset;
		req->r_data.listio.r_cmd = cmd;
		req->r_data.listio.r_aio_strat =
		    (aio_strat == NULL) ? 0 : aio_strat->m_value;
		req->r_data.listio.r_filestride = 0;
		req->r_data.listio.r_memstride = 0;
		req->r_data.listio.r_opcode = opcode;
		req->r_data.listio.r_nstrides = 1;
		req->r_data.listio.r_nbytes = length;
		req->r_data.listio.r_uflags =
		    (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;

		if (opcode == LO_WRITE) {
			req->r_data.listio.r_pattern = pattern;
			req->r_data.listio.r_oflags = O_WRONLY | flags->m_value;
		} else {
			req->r_data.listio.r_oflags = O_RDONLY | flags->m_value;
		}
#endif
		break;
	}

	return 0;
}

/*
 * Get information about a file that iogen uses to choose io length and
 * offset.  Information gathered is file length, iounit, and raw iounit.
 * For regurlar files, iounit is 1, and raw iounit is the iounit of the
 * device on which the file resides.  For block/character special files
 * the iounit and raw iounit are both the iounit of the device.
 *
 * Note:	buffered and osync io must be iounit aligned
 *		raw and ossd io must be raw iounit aligned
 */

int get_file_info(struct file_info *rec)
{
	struct stat sbuf;
#ifdef CRAY
	struct lk_device_info dinfo;
#endif
#ifdef sgi
	int fd;
	struct dioattr finfo;
#endif

	/*
	 * Figure out if the files is regular, block or character special.  Any
	 * other type is an error.
	 */

	if (stat(rec->f_path, &sbuf) == -1) {
		fprintf(stderr,
			"iogen%s: get_file_info():  Could not stat() %s:  %s\n",
			TagName, rec->f_path, SYSERR);
		return -1;
	}
#if _CRAY2
	if ((!S_ISREG(sbuf.st_mode)) || strncmp(rec->f_path, "/dev/", 5) == 0) {
		fprintf(stderr,
			"iogen%s:  device level io not supported on cray2\n",
			TagName);
		return -1;
	}
#endif

	rec->f_type = sbuf.st_mode & S_IFMT;

	/*
	 * If regular, iou is 1, and we must figure out the device on
	 * which the file resides.  riou is the iou (logical sector size) of
	 * this device.
	 */

	if (S_ISREG(sbuf.st_mode)) {
		rec->f_iou = 1;
		rec->f_length = sbuf.st_size;

		/*
		 * If -r used, take Rawmult as the raw/ssd io multiple.  Otherwise
		 * attempt to determine it by looking at the device the file
		 * resides on.
		 */

		if (r_opt) {
			rec->f_riou = Rawmult;
			return 0;
		}
#ifdef CRAY
		if (lk_rawdev(rec->f_path, dinfo.path, sizeof(dinfo.path), 0) ==
		    -1)
			return -1;

		if (lk_devinfo(&dinfo, 0) == -1) {
			/* can't get raw I/O unit -- use stat to fudge it */
			rec->f_riou = sbuf.st_blksize;
		} else {
			rec->f_riou = ctob(dinfo.iou);
		}
#endif
#ifdef linux
		rec->f_riou = BSIZE;
#endif
#ifdef sgi
		if ((fd = open(rec->f_path, O_RDWR | O_DIRECT, 0)) != -1) {
			if (fcntl(fd, F_DIOINFO, &finfo) != -1) {
				rec->f_riou = finfo.d_miniosz;
			} else {
				fprintf(stderr,
					"iogen%s: Error %s (%d) getting direct I/O info of file %s\n",
					TagName, strerror(errno), errno,
					rec->f_path);
			}
			close(fd);
		} else {
			rec->f_riou = BBSIZE;
		}
#endif /* SGI */

	} else {

#ifdef CRAY
		/*
		 * Otherwise, file is a device.  Use lk_devinfo() to get its logical
		 * sector size.  This is the iou and riou
		 */

		strcpy(dinfo.path, rec->f_path);

		if (lk_devinfo(&dinfo, 0) == -1) {
			fprintf(stderr, "iogen%s: %s:  %s\n", TagName,
				Lk_err_func, Lk_err_mesg);
			return -1;
		}

		rec->f_iou = ctob(dinfo.iou);
		rec->f_riou = ctob(dinfo.iou);
		rec->f_length = ctob(dinfo.length);
#else
#ifdef sgi
		rec->f_riou = BBSIZE;
		rec->f_length = BBSIZE;
#else
		rec->f_riou = BSIZE;
		rec->f_length = BSIZE;
#endif /* sgi */
#endif /* CRAY */
	}

	return 0;
}

/*
 * Create file path as nbytes long.  If path exists, the file will either be
 * extended or truncated to be nbytes long.  Returns final size of file,
 * or -1 if there was a failure.
 */

int create_file(char *path, int nbytes)
{
	int fd, rval;
	char c;
	struct stat sbuf;
#ifdef sgi
	int nb;
	struct flock f;
	struct fsxattr xattr;
	struct dioattr finfo;
	char *b, *buf;
#endif

	errno = 0;
	rval = stat(path, &sbuf);

	if (rval == -1) {
		if (errno == ENOENT) {
			sbuf.st_size = 0;
		} else {
			fprintf(stderr,
				"iogen%s:  Could not stat file %s:  %s (%d)\n",
				TagName, path, SYSERR, errno);
			return -1;
		}
	} else {
		if (!S_ISREG(sbuf.st_mode)) {
			fprintf(stderr,
				"iogen%s:  file %s exists, but is not a regular file - cannot modify length\n",
				TagName, path);
			return -1;
		}
	}

	if (sbuf.st_size == nbytes)
		return nbytes;

	Oflags |= O_CREAT | O_WRONLY;

	if ((fd = open(path, Oflags, 0666)) == -1) {
		fprintf(stderr,
			"iogen%s:  Could not create/open file %s: %s (%d)\n",
			TagName, path, SYSERR, errno);
		return -1;
	}

	/*
	 * Truncate file if it is longer than nbytes, otherwise attempt to
	 * pre-allocate file blocks.
	 */

	if (sbuf.st_size > nbytes) {
		if (ftruncate(fd, nbytes) == -1) {
			fprintf(stderr,
				"iogen%s:  Could not ftruncate() %s to %d bytes:  %s (%d)\n",
				TagName, path, nbytes, SYSERR, errno);
			close(fd);
			return -1;
		}
	} else {

#ifdef sgi
		/*
		 *  The file must be designated as Real-Time before any data
		 *  is allocated to it.
		 *
		 */
		if (Orealtime != 0) {
			memset(&xattr, 0x00, sizeof(xattr));
			xattr.fsx_xflags = XFS_XFLAG_REALTIME;
			/*fprintf(stderr, "set: fsx_xflags = 0x%x\n", xattr.fsx_xflags); */
			if (fcntl(fd, F_FSSETXATTR, &xattr) == -1) {
				fprintf(stderr,
					"iogen%s: Error %s (%d) setting XFS XATTR->Realtime on file %s\n",
					TagName, SYSERR, errno, path);
				close(fd);
				return -1;
			}
#ifdef DEBUG
			if (fcntl(fd, F_FSGETXATTR, &xattr) == -1) {
				fprintf(stderr,
					"iogen%s: Error getting realtime flag %s (%d)\n",
					TagName, SYSERR, errno);
				close(fd);
				return -1;
			} else {
				fprintf(stderr, "get: fsx_xflags = 0x%x\n",
					xattr.fsx_xflags);
			}
#endif
		}

		/*
		 * Reserve space with F_RESVSP
		 *
		 * Failure is ignored since F_RESVSP only works on XFS and the
		 * filesystem could be on EFS or NFS
		 */
		if (Oreserve) {
			f.l_whence = SEEK_SET;
			f.l_start = 0;
			f.l_len = nbytes;

			/*fprintf(stderr,
			   "create_file: fcntl(%d, F_RESVSP, { %d, %lld, %lld })\n",
			   fd, f.l_whence, (long long)f.l_start, (long long)f.l_len); */

			/* non-zeroing reservation */
			if (fcntl(fd, F_RESVSP, &f) == -1) {
				fprintf(stderr,
					"iogen%s:  Could not fcntl(F_RESVSP) %d bytes in file %s: %s (%d)\n",
					TagName, nbytes, path, SYSERR, errno);
				close(fd);
				return -1;
			}
		}

		if (Oallocate) {
			/* F_ALLOCSP allocates from the start of the file to l_start */
			f.l_whence = SEEK_SET;
			f.l_start = nbytes;
			f.l_len = 0;
			/*fprintf(stderr,
			   "create_file: fcntl(%d, F_ALLOCSP, { %d, %lld, %lld })\n",
			   fd, f.l_whence, (long long)f.l_start,
			   (long long)f.l_len); */

			/* zeroing reservation */
			if (fcntl(fd, F_ALLOCSP, &f) == -1) {
				fprintf(stderr,
					"iogen%s:  Could not fcntl(F_ALLOCSP) %d bytes in file %s: %s (%d)\n",
					TagName, nbytes, path, SYSERR, errno);
				close(fd);
				return -1;
			}
		}
#endif /* sgi */

		/*
		 * Write a byte at the end of file so that stat() sets the right
		 * file size.
		 */

#ifdef sgi
		if (Owrite == 2) {
			close(fd);
			if ((fd =
			     open(path, O_CREAT | O_RDWR | O_DIRECT,
				  0)) != -1) {
				if (fcntl(fd, F_DIOINFO, &finfo) == -1) {
					fprintf(stderr,
						"iogen%s: Error %s (%d) getting direct I/O info for file %s\n",
						TagName, SYSERR, errno, path);
					return -1;
				} else {
					/*fprintf(stderr, "%s: miniosz=%d\n",
					   path, finfo.d_miniosz); */
				}
			} else {
				fprintf(stderr,
					"iogen%s: Error %s (%d) opening file %s with flags O_CREAT|O_RDWR|O_DIRECT\n",
					TagName, SYSERR, errno, path);
				return -1;
			}

			/*
			 * nb is nbytes adjusted down by an even d_miniosz block
			 *
			 * Note: the first adjustment can cause iogen to print a warning
			 *  about not being able to create a file of <nbytes> length,
			 *  since the file will be shorter.
			 */
			nb = nbytes - finfo.d_miniosz;
			nb = nb - nb % finfo.d_miniosz;

			/*fprintf(stderr,
			   "create_file_ow2: lseek(%d, %d {%d %d}, SEEK_SET)\n",
			   fd, nb, nbytes, finfo.d_miniosz); */

			if (lseek(fd, nb, SEEK_SET) == -1) {
				fprintf(stderr,
					"iogen%s:  Could not lseek() to EOF of file %s: %s (%d)\n\tactual offset %d file size goal %d miniosz %lld\n",
					TagName, path, SYSERR, errno,
					nb, nbytes, (long long)finfo.d_miniosz);
				close(fd);
				return -1;
			}

			b = buf = malloc(finfo.d_miniosz + finfo.d_mem);

			if (((long)buf % finfo.d_mem != 0)) {
				buf += finfo.d_mem - ((long)buf % finfo.d_mem);
			}

			memset(buf, 0, finfo.d_miniosz);

			if ((rval =
			     write(fd, buf,
				   finfo.d_miniosz)) != finfo.d_miniosz) {
				fprintf(stderr,
					"iogen%s:  Could not write %d byte length file %s: %s (%d)\n",
					TagName, nb, path, SYSERR, errno);
				fprintf(stderr, "\twrite(%d, 0x%lx, %d) = %d\n",
					fd, (long)buf, finfo.d_miniosz, rval);
				fprintf(stderr,
					"\toffset %d file size goal %d, miniosz=%d\n",
					nb, nbytes, finfo.d_miniosz);
				close(fd);
				return -1;
			}
			free(b);
		} else
#endif /* sgi */
		if (Owrite) {
			/*fprintf(stderr,
			   "create_file_Owrite: lseek(%d, %d {%d}, SEEK_SET)\n",
			   fd, nbytes-1, nbytes); */

			if (lseek(fd, nbytes - 1, SEEK_SET) == -1) {
				fprintf(stderr,
					"iogen%s:  Could not lseek() to EOF in file %s:  %s (%d)\n\toffset goal %d\n",
					TagName, path, SYSERR, errno,
					nbytes - 1);
				close(fd);
				return -1;
			}

			if ((rval = write(fd, &c, 1)) != 1) {
				fprintf(stderr,
					"iogen%s:  Could not create a %d byte length file %s: %s (%d)\n",
					TagName, nbytes, path, SYSERR, errno);
				fprintf(stderr,
					"\twrite(%d, 0x%lx, %d) = %d\n",
					fd, (long)&c, 1, rval);
				fprintf(stderr,
					"\toffset %d file size goal %d\n",
					nbytes - 1, nbytes);
				close(fd);
				return -1;
			}
		}
	}

	fstat(fd, &sbuf);
	close(fd);

	return sbuf.st_size;
}

/*
 * Function to convert a string to its corresponding value in a strmap array.
 * If the string is not found in the array, the value corresponding to the
 * NULL string (the last element in the array) is returned.
 */

int str_to_value(struct strmap *map, char *str)
{
	struct strmap *mp;

	for (mp = map; mp->m_string != NULL; mp++)
		if (strcmp(mp->m_string, str) == 0)
			break;

	return mp->m_value;
}

/*
 * Function to convert a string to its corresponding entry in a strmap array.
 * If the string is not found in the array, a NULL is returned.
 */

struct strmap *str_lookup(struct strmap *map, char *str)
{
	struct strmap *mp;

	for (mp = map; mp->m_string != NULL; mp++)
		if (strcmp(mp->m_string, str) == 0)
			break;

	return ((mp->m_string == NULL) ? NULL : mp);
}

/*
 * Function to convert a value to its corresponding string in a strmap array.
 * If the value is not found in the array, NULL is returned.
 */

char *value_to_string(struct strmap *map, int val)
{
	struct strmap *mp;

	for (mp = map; mp->m_string != NULL; mp++)
		if (mp->m_value == val)
			break;

	return mp->m_string;
}

/*
 * Interpret cmdline options/arguments.  Exit with 1 if something on the
 * cmdline isn't kosher.
 */

int parse_cmdline(int argc, char **argv, char *opts)
{
	int o, len, nb, format_error;
	struct strmap *flgs, *sc;
	char *file, *cp, ch;
	extern int opterr;
	extern int optind;
	extern char *optarg;
	struct strmap *mp;
	struct file_info *fptr;
	int nopenargs;
	char *openargs[5];	/* Flags, cbits, cblks */
	char *errmsg;
	int str_to_int();
	opterr = 0;
#ifndef linux
	char *ranges;
	struct strmap *type;
#endif

	while ((o = getopt(argc, argv, opts)) != EOF) {
		switch ((char)o) {

		case 'a':
#ifdef linux
			fprintf(stderr,
				"iogen%s:  Unrecognized option -a on this platform\n",
				TagName);
			exit(2);
#else
			cp = strtok(optarg, ",");
			while (cp != NULL) {
				if ((type =
				     str_lookup(Aio_Strat_Map, cp)) == NULL) {
					fprintf(stderr,
						"iogen%s:  Unrecognized aio completion strategy:  %s\n",
						TagName, cp);
					exit(2);
				}

				Aio_Strat_List[Naio_Strat_Types++] = type;
				cp = strtok(NULL, ",");
			}
			a_opt++;
#endif
			break;

		case 'f':
			cp = strtok(optarg, ",");
			while (cp != NULL) {
				if ((flgs = str_lookup(Flag_Map, cp)) == NULL) {
					fprintf(stderr,
						"iogen%s:  Unrecognized flags:  %s\n",
						TagName, cp);
					exit(2);
				}

				cp = strtok(NULL, ",");

#ifdef O_SSD
				if (flgs->m_value & O_SSD && !Sds_Avail) {
					fprintf(stderr,
						"iogen%s:  Warning - no sds available, ignoring ssd flag\n",
						TagName);
					continue;
				}
#endif

				Flag_List[Nflags++] = flgs;
			}
			f_opt++;
			break;

		case 'h':
			help(stdout);
			exit(0);
			break;

		case 'i':
			format_error = 0;

			switch (sscanf(optarg, "%i%c", &Iterations, &ch)) {
			case 1:
				Time_Mode = 0;
				break;

			case 2:
				if (ch == 's')
					Time_Mode = 1;
				else
					format_error = 1;
				break;

			default:
				format_error = 1;
			}

			if (Iterations < 0)
				format_error = 1;

			if (format_error) {
				fprintf(stderr,
					"iogen%s:  Illegal -i arg (%s):  Must be of the format:  number[s]\n",
					TagName, optarg);
				fprintf(stderr,
					"        where 'number' is >= 0\n");
				exit(1);
			}

			i_opt++;
			break;

		case 'L':
#ifdef linux
			fprintf(stderr,
				"iogen%s:  Unrecognized option -L on this platform\n",
				TagName);
			exit(2);
#else
			if (parse_ranges(optarg, 1, 255, 1, NULL, &ranges,
					 &errmsg) == -1) {
				fprintf(stderr,
					"iogen%s: error parsing listio range '%s': %s\n",
					TagName, optarg, errmsg);
				exit(1);
			}

			Minstrides = range_min(ranges, 0);
			Maxstrides = range_max(ranges, 0);

			free(ranges);
			L_opt++;
#endif
			break;

		case 'm':
			if ((Offset_Mode =
			     str_lookup(Omode_Map, optarg)) == NULL) {
				fprintf(stderr,
					"iogen%s:  Illegal -m arg (%s)\n",
					TagName, optarg);
				exit(1);
			}

			m_opt++;
			break;

		case 'N':
			sprintf(TagName, "(%.39s)", optarg);
			break;

		case 'o':
			o_opt++;
			break;

		case 'O':

			nopenargs = string_to_tokens(optarg, openargs, 4, ":/");

#ifdef CRAY
			if (nopenargs)
				sscanf(openargs[1], "%i", &Ocbits);
			if (nopenargs > 1)
				sscanf(openargs[2], "%i", &Ocblks);

			Oflags = parse_open_flags(openargs[0], &errmsg);
			if (Oflags == -1) {
				fprintf(stderr, "iogen%s: -O %s error: %s\n",
					TagName, optarg, errmsg);
				exit(1);
			}
#endif
#ifdef linux
			Oflags = parse_open_flags(openargs[0], &errmsg);
			if (Oflags == -1) {
				fprintf(stderr, "iogen%s: -O %s error: %s\n",
					TagName, optarg, errmsg);
				exit(1);
			}
#endif
#ifdef sgi
			if (!strcmp(openargs[0], "realtime")) {
				/*
				 * -O realtime:extsize
				 */
				Orealtime = 1;
				if (nopenargs > 1)
					sscanf(openargs[1], "%i", &Oextsize);
				else
					Oextsize = 0;
			} else if (!strcmp(openargs[0], "allocate") ||
				   !strcmp(openargs[0], "allocsp")) {
				/*
				 * -O allocate
				 */
				Oreserve = 0;
				Oallocate = 1;
			} else if (!strcmp(openargs[0], "reserve")) {
				/*
				 * -O [no]reserve
				 */
				Oallocate = 0;
				Oreserve = 1;
			} else if (!strcmp(openargs[0], "noreserve")) {
				/* Oreserve=1 by default; this clears that default */
				Oreserve = 0;
			} else if (!strcmp(openargs[0], "nowrite")) {
				/* Owrite=1 by default; this clears that default */
				Owrite = 0;
			} else if (!strcmp(openargs[0], "direct")) {
				/* this means "use direct i/o to preallocate file" */
				Owrite = 2;
			} else {
				fprintf(stderr,
					"iogen%s: Error: -O %s error: unrecognized option\n",
					TagName, openargs[0]);
				exit(1);
			}
#endif

			O_opt++;
			break;

		case 'p':
			Outpipe = optarg;
			p_opt++;
			break;

		case 'r':
			if ((Rawmult = bytes_by_prefix(optarg)) == -1 ||
			    Rawmult < 11 || Rawmult % BSIZE) {
				fprintf(stderr,
					"iogen%s:  Illegal -r arg (%s).  Must be > 0 and multipe of BSIZE (%d)\n",
					TagName, optarg, BSIZE);
				exit(1);
			}

			r_opt++;
			break;

		case 's':
			cp = strtok(optarg, ",");
			while (cp != NULL) {
				if ((sc = str_lookup(Syscall_Map, cp)) == NULL) {
					fprintf(stderr,
						"iogen%s:  Unrecognized syscall:  %s\n",
						TagName, cp);
					exit(2);
				}

				do {
					/* >>> sc->m_flags & FLG_SDS */
					if (sc->m_value != SSREAD
					    && sc->m_value != SSWRITE)
						Fileio++;

					Syscall_List[Nsyscalls++] = sc;
				} while ((sc = str_lookup(++sc, cp)) != NULL);

				cp = strtok(NULL, ",");
			}
			s_opt++;
			break;

		case 't':
			if ((Mintrans = bytes_by_prefix(optarg)) == -1) {
				fprintf(stderr,
					"iogen%s:  Illegal -t arg (%s):  Must have the form num[bkm]\n",
					TagName, optarg);
				exit(1);
			}
			t_opt++;
			break;

		case 'T':
			if ((Maxtrans = bytes_by_prefix(optarg)) == -1) {
				fprintf(stderr,
					"iogen%s:  Illegal -T arg (%s):  Must have the form num[bkm]\n",
					TagName, optarg);
				exit(1);
			}
			T_opt++;
			break;

		case 'q':
			q_opt++;
			break;

		case '?':
			usage(stderr);
			exit(1);
		}
	}

	/*
	 * Supply defaults
	 */

	if (!L_opt) {
		Minstrides = 1;
		Maxstrides = 255;
	}

	if (!m_opt)
		Offset_Mode = str_lookup(Omode_Map, "sequential");

	if (!i_opt)
		Iterations = 0;

	if (!t_opt)
		Mintrans = 1;

	if (!T_opt)
		Maxtrans = 256 * BSIZE;

	if (!O_opt)
		Oflags = Ocbits = Ocblks = 0;

	/*
	 * Supply default async io completion strategy types.
	 */

	if (!a_opt) {
		for (mp = Aio_Strat_Map; mp->m_string != NULL; mp++) {
			Aio_Strat_List[Naio_Strat_Types++] = mp;
		}
	}

	/*
	 * Supply default syscalls.  Default is read,write,reada,writea,listio.
	 */

	if (!s_opt) {
		Nsyscalls = 0;
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "read");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "write");
#ifdef CRAY
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "reada");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "writea");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lread");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lreada");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lwrite");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lwritea");
#endif

#ifdef sgi
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pread");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pwrite");
		/*Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "aread"); */
		/*Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "awrite"); */
#endif

#ifndef CRAY
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "readv");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "writev");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmread");
		Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmwrite");
#endif

		Fileio = 1;
	}

	if (Fileio && (argc - optind < 1)) {
		fprintf(stderr, "iogen%s:  No files specified on the cmdline\n",
			TagName);
		exit(1);
	}

	/*
	 * Supply default file io flags - defaut is 'buffered,raw,sync,ldraw'.
	 */

	if (!f_opt && Fileio) {
		Nflags = 0;
		Flag_List[Nflags++] = str_lookup(Flag_Map, "buffered");
		Flag_List[Nflags++] = str_lookup(Flag_Map, "sync");
#ifdef CRAY
		Flag_List[Nflags++] = str_lookup(Flag_Map, "raw+wf");
		Flag_List[Nflags++] = str_lookup(Flag_Map, "ldraw");
#endif

#ifdef sgi
		/* Warning: cannot mix direct i/o with others! */
		Flag_List[Nflags++] = str_lookup(Flag_Map, "dsync");
		Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync");
		/* Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync+sync"); */
		/* Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync+dsync"); */
#endif
	}

	if (Fileio) {
		if (optind >= argc) {
			fprintf(stderr,
				"iogen%s:  No files listed on the cmdline\n",
				TagName);
			exit(1);
		}

		/*
		 * Initialize File_List[] - only necessary if doing file io.  First
		 * space for the File_List array, then fill it in.
		 */

		File_List = malloc((argc - optind) * sizeof(struct file_info));

		if (File_List == NULL) {
			fprintf(stderr,
				"iogen%s:  Could not malloc space for %d file_info structures\n",
				TagName, argc - optind);
			exit(2);
		}

		memset(File_List, 0,
		       (argc - optind) * sizeof(struct file_info));

		Nfiles = 0;
		while (optind < argc) {
			len = -1;

			/*
			 * Pick off leading len: if it's there and create/extend/trunc
			 * the file to the desired length.  Otherwise, just make sure
			 * the file is accessable.
			 */

			if ((cp = strchr(argv[optind], ':')) != NULL) {
				*cp = '\0';
				if ((len = bytes_by_prefix(argv[optind])) == -1) {
					fprintf(stderr,
						"iogen%s:  illegal file length (%s) for file %s\n",
						TagName, argv[optind], cp + 1);
					exit(2);
				}
				*cp = ':';
				file = cp + 1;

				if (strlen(file) > MAX_FNAME_LENGTH) {
					fprintf(stderr,
						"iogen%s:  Max fname length is %d chars - ignoring file %s\n",
						TagName, MAX_FNAME_LENGTH,
						file);
					optind++;
					continue;
				}

				nb = create_file(file, len);

				if (nb < len) {
					fprintf(stderr,
						"iogen%s warning:  Couldn't create file %s of %d bytes\n",
						TagName, file, len);

					if (nb <= 0) {
						optind++;
						continue;
					}
				}
			} else {
				file = argv[optind];
				if (access(file, R_OK | W_OK) == -1) {
					fprintf(stderr,
						"iogen%s:  file %s cannot be accessed for reading and/or writing:  %s (%d)\n",
						TagName, file, SYSERR, errno);
					exit(2);
				}
			}

			/*
			 * get per-file information
			 */

			fptr = &File_List[Nfiles];

			if (file[0] == '/') {
				strcpy(fptr->f_path, file);
			} else {
				if (getcwd
				    (fptr->f_path,
				     sizeof(fptr->f_path) - 1) == NULL)
					perror
					    ("Could not get current working directory");
				strcat(fptr->f_path, "/");
				strcat(fptr->f_path, file);
			}

			if (get_file_info(fptr) == -1) {
				fprintf(stderr,
					"iogen%s warning:  Error getting file info for %s\n",
					TagName, file);
			} else {

				/*
				 * If the file length is smaller than our min transfer size,
				 * ignore it.
				 */

				if (fptr->f_length < Mintrans) {
					fprintf(stderr,
						"iogen%s warning:  Ignoring file %s\n",
						TagName, fptr->f_path);
					fprintf(stderr,
						"                length (%d) is < min transfer size (%d)\n",
						fptr->f_length, Mintrans);
					optind++;
					continue;
				}

				/*
				 * If the file length is smaller than our max transfer size,
				 * ignore it.
				 */

				if (fptr->f_length < Maxtrans) {
					fprintf(stderr,
						"iogen%s warning:  Ignoring file %s\n",
						TagName, fptr->f_path);
					fprintf(stderr,
						"                length (%d) is < max transfer size (%d)\n",
						fptr->f_length, Maxtrans);
					optind++;
					continue;
				}

				if (fptr->f_length > 0) {
					switch (Offset_Mode->m_value) {
					case M_SEQUENTIAL:
						fptr->f_lastoffset = 0;
						fptr->f_lastlength = 0;
						break;

					case M_REVERSE:
						fptr->f_lastoffset =
						    fptr->f_length;
						fptr->f_lastlength = 0;
						break;

					case M_RANDOM:
						fptr->f_lastoffset =
						    fptr->f_length / 2;
						fptr->f_lastlength = 0;
						break;
					}

					Nfiles++;
				}
			}

			optind++;
		}

		if (Nfiles == 0) {
			fprintf(stderr,
				"iogen%s:  Could not create, or gather info for any test files\n",
				TagName);
			exit(2);
		}
	}

	return 0;
}

int help(FILE * stream)
{
	usage(stream);
	fprintf(stream, "\n");
#ifndef linux
	fprintf(stream,
		"\t-a aio_type,...  Async io completion types to choose.  Supported types\n");
#ifdef CRAY
#if _UMK || RELEASE_LEVEL >= 8000
	fprintf(stream,
		"\t                 are:  poll, signal, recall, recalla, and recalls.\n");
#else
	fprintf(stream,
		"\t                 are:  poll, signal, recalla, and recalls.\n");
#endif
#else
	fprintf(stream,
		"\t                 are:  poll, signal, suspend, and callback.\n");
#endif
	fprintf(stream, "\t                 Default is all of the above.\n");
#else /* !linux */
	fprintf(stream, "\t-a               (Not used on Linux).\n");
#endif /* !linux */
	fprintf(stream,
		"\t-f flag,...      Flags to use for file IO.  Supported flags are\n");
#ifdef CRAY
	fprintf(stream,
		"\t                 raw, ssd, buffered, ldraw, sync,\n");
	fprintf(stream,
		"\t                 raw+wf, raw+wf+ldraw, raw+wf+ldraw+sync,\n");
	fprintf(stream,
		"\t                 and parallel (unicos/mk on MPP only).\n");
	fprintf(stream,
		"\t                 Default is 'raw,ldraw,sync,buffered'.\n");
#else
#ifdef sgi
	fprintf(stream,
		"\t                 buffered, direct, sync, dsync, rsync,\n");
	fprintf(stream, "\t                 rsync+dsync.\n");
	fprintf(stream,
		"\t                 Default is 'buffered,sync,dsync,rsync'.\n");
#else
	fprintf(stream, "\t                 buffered, sync.\n");
	fprintf(stream, "\t                 Default is 'buffered,sync'.\n");
#endif /* sgi */
#endif /* CRAY */
	fprintf(stream, "\t-h               This help.\n");
	fprintf(stream,
		"\t-i iterations[s] # of requests to generate.  0 means causes iogen\n");
	fprintf(stream,
		"\t                 to run until it's killed.  If iterations is suffixed\n");
	fprintf(stream,
		"\t                 with 's', then iterations is the number of seconds\n");
	fprintf(stream,
		"\t                 that iogen should run for.  Default is '0'.\n");
#ifndef linux
	fprintf(stream,
		"\t-L min:max       listio nstrides / nrequests range\n");
#else
	fprintf(stream, "\t-L               (Not used on Linux).\n");
#endif /* !linux */
	fprintf(stream,
		"\t-m offset-mode   The mode by which iogen chooses the offset for\n");
	fprintf(stream,
		"\t                 consectutive transfers within a given file.\n");
	fprintf(stream,
		"\t                 Allowed values are 'random', 'sequential',\n");
	fprintf(stream, "\t                 and 'reverse'.\n");
	fprintf(stream, "\t                 sequential is the default.\n");
	fprintf(stream, "\t-N tagname       Tag name, for Monster.\n");
	fprintf(stream,
		"\t-o               Form overlapping consecutive requests.\n");
	fprintf(stream, "\t-O               Open flags for creating files\n");
#ifdef CRAY
	fprintf(stream,
		"\t                 {O_PLACE,O_BIG,etc}[:CBITS[:CBLKS]]\n");
#endif
#ifdef sgi
	fprintf(stream,
		"\t                 realtime:extsize - put file on real-time volume\n");
	fprintf(stream,
		"\t                 allocate - allocate space with F_ALLOCSP\n");
	fprintf(stream,
		"\t                 reserve - reserve space with F_RESVSP (default)\n");
	fprintf(stream,
		"\t                 noreserve - do not reserve with F_RESVSP\n");
	fprintf(stream,
		"\t                 direct - use O_DIRECT I/O to write to the file\n");
#endif
#ifdef linux
	fprintf(stream, "\t                 {O_SYNC,etc}\n");
#endif
	fprintf(stream,
		"\t-p               Output pipe.  Default is stdout.\n");
	fprintf(stream,
		"\t-q               Quiet mode.  Normally iogen spits out info\n");
	fprintf(stream,
		"\t                 about test files, options, etc. before starting.\n");
	fprintf(stream,
		"\t-s syscall,...   Syscalls to do.  Supported syscalls are\n");
#ifdef sgi
	fprintf(stream,
		"\t                 read, write, pread, pwrite, readv, writev\n");
	fprintf(stream,
		"\t                 aread, awrite, resvsp, unresvsp, ffsync,\n");
	fprintf(stream,
		"\t                 mmread, mmwrite, fsync2, fdatasync,\n");
	fprintf(stream,
		"\t                 Default is 'read,write,pread,pwrite,readv,writev,mmread,mmwrite'.\n");
#endif
#ifdef CRAY
	fprintf(stream,
		"\t                 read, write, reada, writea, listio,\n");
	fprintf(stream,
		"\t                 ssread (PVP only), and sswrite (PVP only).\n");
	fprintf(stream,
		"\t                 Default is 'read,write,reada,writea,listio'.\n");
#endif
#ifdef linux
	fprintf(stream, "\t                 read, write, readv, writev,\n");
	fprintf(stream,
		"\t                 mmread, mmwrite, fsync2, fdatasync,\n");
	fprintf(stream,
		"\t                 Default is 'read,write,readv,writev,mmread,mmwrite'.\n");
#endif
	fprintf(stream, "\t-t mintrans      Min transfer length\n");
	fprintf(stream, "\t-T maxtrans      Max transfer length\n");
	fprintf(stream, "\n");
	fprintf(stream,
		"\t[len:]file,...   Test files to do IO against (note ssread/sswrite\n");
	fprintf(stream,
		"\t                 don't need a test file).  The len: syntax\n");
	fprintf(stream,
		"\t                 informs iogen to first create/expand/truncate the\n");
	fprintf(stream, "\t                 to the desired length.\n");
	fprintf(stream, "\n");
	fprintf(stream,
		"\tNote:  The ssd flag causes sds transfers to also be done.\n");
	fprintf(stream,
		"\t       To totally eliminate sds transfers, you must eleminate sds\n");
	fprintf(stream,
		"\t       from the flags (-f) and ssread,ssrite from the syscalls (-s)\n");
	fprintf(stream,
		"\tThe mintrans, maxtrans, and len: parameters are numbers of the\n");
	fprintf(stream,
		"\tform [0-9]+[bkm].  The optional trailing b, k, or m multiplies\n");
	fprintf(stream,
		"\tthe number by blocks, kilobytes, or megabytes.  If no trailing\n");
	fprintf(stream,
		"\tmultiplier is present, the number is interpreted as bytes\n");

	return 0;
}

/*
 * Obvious - usage clause
 */

int usage(FILE * stream)
{
	fprintf(stream,
		"usage%s:  iogen [-hoq] [-a aio_type,...] [-f flag[,flag...]] [-i iterations] [-p outpipe] [-m offset-mode] [-s syscall[,syscall...]] [-t mintrans] [-T maxtrans] [ -O file-create-flags ] [[len:]file ...]\n",
		TagName);
	return 0;
}