/*
 * 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/
 */
/*
 *
 * Lib i/o
 *
 * This file contains several functions to doing reads and writes.
 * It was written so that a single function could be called in a test
 * program and only a io type field value would have to change to
 * do different types of io.  There is even a couple of functions that
 * will allow you to parse a string to determine the iotype.
 *
 * This file contains functions for writing/reading to/from open files
 * Prototypes:
 *
 * Functions declared in this module - see individual function code for
 * usage comments:
 *
 *  int	 stride_bounds(int offset, int stride, int nstrides,
 *		      int bytes_per_stride, int *min, int *max);

 *  int  lio_write_buffer(int fd, int method, char *buffer, int size,
 *						char **errmsg, long wrd);
 *  int  lio_read_buffer(int fd, int method, char *buffer, int size,
 *						char **errmsg, long wrd);
 *
 *  #ifdef CRAY
 *  int  lio_wait4asyncio(int method, int fd, struct iosw **statptr)
 *  int  lio_check_asyncio(char *io_type, int size, struct iosw *status)
 *  #endif
 *  #ifdef sgi
 *  int  lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
 *  int  lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
 *  #endif
 *
 *  int  lio_parse_io_arg1(char *string)
 *  void lio_help1(char *prefix);
 *
 *  int  lio_parse_io_arg2(char *string, char **badtoken)
 *  void lio_help2(char *prefix);
 *
 *  int  lio_set_debug(int level);
 *
 *  char Lio_SysCall[];
 *  struct lio_info_type Lio_info1[];
 *  struct lio_info_type Lio_info2[];
 *
 *  Author : Richard Logan
 *
 */

#ifdef __linux__
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#define _LARGEFILE64_SOURCE
#endif
#include "config.h"
#include <stdio.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/param.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/file.h>
#include <signal.h>
#include <stdint.h>
#ifdef CRAY
#include <sys/secparm.h>
#include <sys/iosw.h>
#include <sys/listio.h>
#else
/* for linux or sgi */
#include <sys/uio.h>		/* readv(2)/writev(2) */
#include <string.h>		/* bzero */
#endif
#if defined(__linux__) || defined(__sun) || defined(__hpux) || defined(_AIX)
#if !defined(UCLINUX) && !defined(__UCLIBC__)
#include <aio.h>
#endif
#endif
#include <stdlib.h>		/* atoi, abs */

#include "tlibio.h"		/* defines LIO* marcos */
#include "random_range.h"

#ifndef PATH_MAX
#define PATH_MAX	MAXPATHLEN
#endif

#if 0				/* disabled until it's needed -- roehrich 6/11/97 */
#define BUG1_workaround	1	/* Work around a condition where aio_return gives
				 * a value of zero but there is no errno followup
				 * and the read/write operation actually did its
				 * job.   spr/pv 705244
				 */
#endif

static void lio_async_signal_handler();
#ifdef sgi
static void lio_async_callback_handler();
#endif

/*
 * Define the structure as used in lio_parse_arg1 and lio_help1
 */
struct lio_info_type Lio_info1[] = {
	{"s", LIO_IO_SYNC, "sync i/o"},
	{"p", LIO_IO_ASYNC | LIO_WAIT_SIGACTIVE,
	 "async i/o using a loop to wait for a signal"},
	{"b", LIO_IO_ASYNC | LIO_WAIT_SIGPAUSE, "async i/o using pause"},
	{"a", LIO_IO_ASYNC | LIO_WAIT_RECALL,
	 "async i/o using recall/aio_suspend"},
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	{"r",
	 LIO_RANDOM | LIO_IO_TYPES | LIO_WAIT_TYPES,
	 "random sync i/o types and wait methods"},
	{"R",
	 LIO_RANDOM | LIO_IO_ATYPES | LIO_WAIT_ATYPES,
	 "random i/o types and wait methods"},
#else
	{"r",
	 LIO_RANDOM | LIO_IO_TYPES | LIO_WAIT_TYPES,
	 "random i/o types and wait methods"},
	{"R",
	 LIO_RANDOM | LIO_IO_TYPES | LIO_WAIT_TYPES,
	 "random i/o types and wait methods"},
#endif
	{"l", LIO_IO_SLISTIO | LIO_WAIT_RECALL, "single stride sync listio"},
	{"L", LIO_IO_ALISTIO | LIO_WAIT_RECALL,
	 "single stride async listio using recall"},
	{"X", LIO_IO_ALISTIO | LIO_WAIT_SIGPAUSE,
	 "single stride async listio using pause"},
	{"v", LIO_IO_SYNCV, "single buffer sync readv/writev"},
	{"P", LIO_IO_SYNCP, "sync pread/pwrite"},
};

/*
 * Define the structure used by lio_parse_arg2 and lio_help2
 */
struct lio_info_type Lio_info2[] = {
	{"sync", LIO_IO_SYNC, "sync i/o (read/write)"},
	{"async", LIO_IO_ASYNC, "async i/o (reada/writea/aio_read/aio_write)"},
	{"slistio", LIO_IO_SLISTIO, "single stride sync listio"},
	{"alistio", LIO_IO_ALISTIO, "single stride async listio"},
	{"syncv", LIO_IO_SYNCV, "single buffer sync readv/writev"},
	{"syncp", LIO_IO_SYNCP, "pread/pwrite"},
	{"active", LIO_WAIT_ACTIVE, "spin on status/control values"},
	{"recall", LIO_WAIT_RECALL,
	 "use recall(2)/aio_suspend(3) to wait for i/o to complete"},
	{"sigactive", LIO_WAIT_SIGACTIVE, "spin waiting for signal"},
	{"sigpause", LIO_WAIT_SIGPAUSE, "call pause(2) to wait for signal"},
/* nowait is a touchy thing, it's an accident that this implementation worked at all.  6/27/97 roehrich */
/*    { "nowait",    LIO_WAIT_NONE,	"do not wait for async io to complete" },*/
	{"random", LIO_RANDOM, "set random bit"},
	{"randomall",
	 LIO_RANDOM | LIO_IO_TYPES | LIO_WAIT_TYPES,
	 "all random i/o types and wait methods (except nowait)"},
};

char Lio_SysCall[PATH_MAX];	/* string containing last i/o system call */

static volatile int Received_signal = 0;	/* number of signals received */
static volatile int Rec_signal;
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
static volatile int Received_callback = 0;	/* number of callbacks received */
static volatile int Rec_callback;
#endif
static char Errormsg[500];
static int Debug_level = 0;

/***********************************************************************
 * stride_bounds()
 *
 * Determine the bounds of a strided request, normalized to offset.  Returns
 * the number of bytes needed to satisfy the request, and optionally sets
 * *min and *max to the mininum and maximum bytes referenced, normalized
 * around offset.
 *
 * Returns -1 on error - the only possible error conditions are illegal values
 * for nstrides and/or bytes_per_stride - both parameters must be >= 0.
 *
 * (maule, 11/16/95)
 ***********************************************************************/

int stride_bounds(offset, stride, nstrides, bytes_per_stride, min, max)
int offset;
int stride;
int nstrides;
int bytes_per_stride;
int *min;
int *max;
{
	int nbytes, min_byte, max_byte;

	/*
	 * sanity checks ...
	 */

	if (nstrides < 0 || bytes_per_stride < 0) {
		return -1;
	}

	if (stride == 0) {
		stride = bytes_per_stride;
	}

	/*
	 * Determine the # of bytes needed to satisfy the request.  This
	 * value, along with the offset argument, determines the min and max
	 * bytes referenced.
	 */

	nbytes = abs(stride) * (nstrides - 1) + bytes_per_stride;

	if (stride < 0) {
		max_byte = offset + bytes_per_stride - 1;
		min_byte = max_byte - nbytes + 1;
	} else {
		min_byte = offset;
		max_byte = min_byte + nbytes - 1;
	}

	if (min != NULL) {
		*min = min_byte;
	}

	if (max != NULL) {
		*max = max_byte;
	}

	return nbytes;
}

/***********************************************************************
 * This function will allow someone to set the debug level.
 ***********************************************************************/
int lio_set_debug(level)
{
	int old;

	old = Debug_level;
	Debug_level = level;
	return old;
}

/***********************************************************************
 * This function will parse a string and return desired io-method.
 * Only the first character of the string is used.
 *
 * This function does not provide for meaningful option arguments,
 * but it supports current growfiles/btlk interface.
 *
 *  (rrl 04/96)
 ***********************************************************************/
int lio_parse_io_arg1(char *string)
{
	unsigned int ind;
	int found = 0;
	int mask = 0;

	/*
	 * Determine if token is a valid string.
	 */
	for (ind = 0; ind < sizeof(Lio_info1) / sizeof(struct lio_info_type);
	     ind++) {
		if (strcmp(string, Lio_info1[ind].token) == 0) {
			mask |= Lio_info1[ind].bits;
			found = 1;
			break;
		}
	}

	if (found == 0) {
		return -1;
	}

	return mask;

}

/***********************************************************************
 * This function will print a help message describing the characters
 * that can be parsed by lio_parse_io_arg1().
 * They will be printed one per line.
 *  (rrl 04/96)
 ***********************************************************************/
void lio_help1(char *prefix)
{
	unsigned int ind;

	for (ind = 0; ind < sizeof(Lio_info1) / sizeof(struct lio_info_type);
	     ind++) {
		printf("%s %s : %s\n", prefix, Lio_info1[ind].token,
		       Lio_info1[ind].desc);
	}

	return;
}

/***********************************************************************
 * This function will parse a string and return the desired io-method.
 * This function will take a comma separated list of io type and wait
 * method tokens as defined in Lio_info2[].  If a token does not match
 * any of the tokens in Lio_info2[], it will be coverted to a number.
 * If it was a number, those bits are also set.
 *
 *  (rrl 04/96)
 ***********************************************************************/
int lio_parse_io_arg2(char *string, char **badtoken)
{
	char *token = string;
	char *cc = token;
	char savecc;
	int found;
	int mask = 0;

	int tmp;
	unsigned int ind;
	char chr;

	if (token == NULL)
		return -1;

	for (;;) {
		for (; ((*cc != ',') && (*cc != '\0')); cc++) ;
		savecc = *cc;
		*cc = '\0';

		found = 0;

		/*
		 * Determine if token is a valid string or number and if
		 * so, add the bits to the mask.
		 */
		for (ind = 0;
		     ind < sizeof(Lio_info2) / sizeof(struct lio_info_type);
		     ind++) {
			if (strcmp(token, Lio_info2[ind].token) == 0) {
				mask |= Lio_info2[ind].bits;
				found = 1;
				break;
			}
		}

		/*
		 * If token does not match one of the defined tokens, determine
		 * if it is a number, if so, add the bits.
		 */
		if (!found) {
			if (sscanf(token, "%i%c", &tmp, &chr) == 1) {
				mask |= tmp;
				found = 1;
			}
		}

		*cc = savecc;

		if (!found) {	/* token is not valid */
			if (badtoken != NULL)
				*badtoken = token;
			return (-1);
		}

		if (savecc == '\0')
			break;

		token = ++cc;
	}

	return mask;
}

/***********************************************************************
 * This function will print a help message describing the tokens
 * that can be parsed by lio_parse_io_arg2().
 * It will print them one per line.
 *
 * (rrl 04/96)
 ***********************************************************************/
void lio_help2(char *prefix)
{
	unsigned int ind;

	for (ind = 0; ind < sizeof(Lio_info2) / sizeof(struct lio_info_type);
	     ind++) {
		printf("%s %s : %s\n", prefix, Lio_info2[ind].token,
		       Lio_info2[ind].desc);
	}
	return;
}

/***********************************************************************
 * This is an internal signal handler.
 * If the handler is called, it will increment the Received_signal
 * global variable.
 ***********************************************************************/
static void lio_async_signal_handler(int sig)
{
	if (Debug_level)
		printf
		    ("DEBUG %s/%d: received signal %d, a signal caught %d times\n",
		     __FILE__, __LINE__, sig, Received_signal + 1);

	Received_signal++;

	return;
}

#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
/***********************************************************************
 * This is an internal callback handler.
 * If the handler is called, it will increment the Received_callback
 * global variable.
 ***********************************************************************/
static void lio_async_callback_handler(sigval_t sigval)
{
	if (Debug_level)
		printf
		    ("DEBUG %s/%d: received callback, nbytes=%ld, a callback called %d times\n",
		     __FILE__, __LINE__, (long)sigval.sival_int,
		     Received_callback + 1);

	Received_callback++;

	return;
}
#endif /* sgi */

/***********************************************************************
 * lio_random_methods
 * This function will randomly choose an io type and wait method
 * from set of io types and wait methods.  Since this information
 * is stored in a bitmask, it randomly chooses an io type from
 * the io type bits specified and does the same for wait methods.
 *
 * Return Value
 * This function will return a value with all non choosen io type
 * and wait method bits cleared.  The LIO_RANDOM bit is also
 * cleared.  All other bits are left unchanged.
 *
 * (rrl 04/96)
 ***********************************************************************/
int lio_random_methods(long curr_mask)
{
	int mask = 0;

	/* remove random select, io type, and wait method bits from curr_mask */
	mask = curr_mask & (~(LIO_IO_TYPES | LIO_WAIT_TYPES | LIO_RANDOM));

	/* randomly select io type from specified io types */
	mask = mask | random_bit(curr_mask & LIO_IO_TYPES);

	/* randomly select wait methods  from specified wait methods */
	mask = mask | random_bit(curr_mask & LIO_WAIT_TYPES);

	return mask;
}

static void wait4sync_io(int fd, int read)
{
	fd_set s;
	FD_ZERO(&s);
	FD_SET(fd, &s);

	select(fd + 1, read ? &s : NULL, read ? NULL : &s, NULL, NULL);
}

/***********************************************************************
 * Generic write function
 * This function can be used to do a write using write(2), writea(2),
 * aio_write(3), writev(2), pwrite(2),
 * or single stride listio(2)/lio_listio(3).
 * By setting the desired bits in the method
 * bitmask, the caller can control the type of write and the wait method
 * that will be used.  If no io type bits are set, write will be used.
 *
 * If async io was attempted and no wait method bits are set then the
 * wait method is: recall(2) for writea(2) and listio(2); aio_suspend(3) for
 * aio_write(3) and lio_listio(3).
 *
 * If multiple wait methods are specified,
 * only one wait method will be used. The order is predetermined.
 *
 * If the call specifies a signal and one of the two signal wait methods,
 * a signal handler for the signal is set.  This will reset an already
 * set handler for this signal.
 *
 * If the LIO_RANDOM method bit is set, this function will randomly
 * choose a io type and wait method from bits in the method argument.
 *
 * If an error is encountered, an error message will be generated
 * in a internal static buffer.  If errmsg is not NULL, it will
 * be updated to point to the static buffer, allowing the caller
 * to print the error message.
 *
 * Return Value
 *   If a system call fails, -errno is returned.
 *   If LIO_WAIT_NONE bit is set, the return value is the return value
 *   of the system call.
 *   If the io did not fail, the amount of data written is returned.
 *	If the size the system call say was written is different
 *	then what was asked to be written, errmsg is updated for
 *	this error condition.  The return value is still the amount
 *	the system call says was written.
 *
 * (rrl 04/96)
 ***********************************************************************/
int lio_write_buffer(fd, method, buffer, size, sig, errmsg, wrd)
int fd;				/* open file descriptor */
int method;			/* contains io type and wait method bitmask */
char *buffer;			/* pointer to buffer */
int size;			/* the size of the io */
int sig;			/* signal to use if async io */
char **errmsg;			/* char pointer that will be updated to point to err message */
long wrd;			/* to allow future features, use zero for now */
{
	int ret = 0;		/* syscall return or used to get random method */
	char *io_type;		/* Holds string of type of io */
	int omethod = method;
	int listio_cmd;		/* Holds the listio/lio_listio cmd */
#ifdef  CRAY
	struct listreq request;	/* Used when a listio is wanted */
	struct iosw status, *statptr[1];
#else
	/* for linux or sgi */
	struct iovec iov;	/* iovec for writev(2) */
#endif
#if defined (sgi)
	aiocb_t aiocbp;		/* POSIX aio control block */
	aiocb_t *aiolist[1];	/* list of aio control blocks for lio_listio */
	off64_t poffset;	/* pwrite(2) offset */
#endif
#if defined(__linux__) && !defined(__UCLIBC__)
	struct aiocb aiocbp;	/* POSIX aio control block */
	struct aiocb *aiolist[1];	/* list of aio control blocks for lio_listio */
	off64_t poffset;	/* pwrite(2) offset */
#endif
	/*
	 * If LIO_RANDOM bit specified, get new method randomly.
	 */
	if (method & LIO_RANDOM) {
		if (Debug_level > 3)
			printf("DEBUG %s/%d: method mask to choose from: %#o\n",
			       __FILE__, __LINE__, method);
		method = lio_random_methods(method);
		if (Debug_level > 2)
			printf("DEBUG %s/%d: random chosen method %#o\n",
			       __FILE__, __LINE__, method);
	}

	if (errmsg != NULL)
		*errmsg = Errormsg;

	Rec_signal = Received_signal;	/* get the current number of signals received */
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	Rec_callback = Received_callback;	/* get the current number of callbacks received */
#endif

#ifdef  CRAY
	memset(&status, 0x00, sizeof(struct iosw));
	memset(&request, 0x00, sizeof(struct listreq));
	statptr[0] = &status;
#else
	/* for linux or sgi */
	memset(&iov, 0x00, sizeof(struct iovec));
	iov.iov_base = buffer;
	iov.iov_len = size;
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
#if defined(sgi)
	memset(&aiocbp, 0x00, sizeof(aiocb_t));
#else
	memset(&aiocbp, 0x00, sizeof(struct aiocb));
#endif
	aiocbp.aio_fildes = fd;
	aiocbp.aio_nbytes = size;
	aiocbp.aio_buf = buffer;
/*    aiocbp.aio_offset = lseek( fd, 0, SEEK_CUR ); -- set below */
	aiocbp.aio_sigevent.sigev_notify = SIGEV_NONE;
	aiocbp.aio_sigevent.sigev_signo = 0;
#ifdef sgi
	aiocbp.aio_sigevent.sigev_func = NULL;
	aiocbp.aio_sigevent.sigev_value.sival_int = 0;
#elif defined(__linux__) && !defined(__UCLIBC__)
	aiocbp.aio_sigevent.sigev_notify_function = NULL;
	aiocbp.aio_sigevent.sigev_notify_attributes = 0;
#endif
	aiolist[0] = &aiocbp;

	if ((ret = lseek(fd, 0, SEEK_CUR)) == -1) {
		ret = 0;
		/* If there is an error and it is not ESPIPE then kick out the error.
		 * If the fd is a fifo then we have to make sure that
		 * lio_random_methods() didn't select pwrite/pread; if it did then
		 * switch to write/read.
		 */
		if (errno == ESPIPE) {
			if (method & LIO_IO_SYNCP) {
				if (omethod & LIO_RANDOM) {
					method &= ~LIO_IO_SYNCP;
					method |= LIO_IO_SYNC;
					if (Debug_level > 2)
						printf
						    ("DEBUG %s/%d: random chosen method switched to %#o for fifo\n",
						     __FILE__, __LINE__,
						     method);
				} else if (Debug_level) {
					printf
					    ("DEBUG %s/%d: pwrite will fail when it writes to a fifo\n",
					     __FILE__, __LINE__);
				}
			}
			/* else: let it ride */
		} else {
			sprintf(Errormsg,
				"%s/%d lseek(fd=%d,0,SEEK_CUR) failed, errno=%d  %s",
				__FILE__, __LINE__, fd, errno, strerror(errno));
			return -errno;
		}
	}
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	poffset = (off64_t) ret;
#endif
	aiocbp.aio_offset = ret;

#endif

	/*
	 * If the LIO_USE_SIGNAL bit is not set, only use the signal
	 * if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are bit.
	 * Otherwise there is not necessary a signal handler to trap
	 * the signal.
	 */
	if (sig && !(method & LIO_USE_SIGNAL) && !(method & LIO_WAIT_SIGTYPES)) {

		sig = 0;	/* ignore signal parameter */
	}
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	if (sig && (method & LIO_WAIT_CBTYPES))
		sig = 0;	/* ignore signal parameter */
#endif

	/*
	 * only setup signal hander if sig was specified and
	 * a sig wait method was specified.
	 * Doing this will change the handler for this signal.  The
	 * old signal handler will not be restored.
	 *** restoring the signal handler could be added ***
	 */

	if (sig && (method & LIO_WAIT_SIGTYPES)) {
#ifdef CRAY
		sigctl(SCTL_REG, sig, lio_async_signal_handler);
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
		aiocbp.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
		aiocbp.aio_sigevent.sigev_signo = sig;
		sigset(sig, lio_async_signal_handler);
#endif /* sgi */
	}
#if defined(sgi)
	else if (method & LIO_WAIT_CBTYPES) {
		/* sival_int just has to be something that I can use
		 * to identify the callback, and "size" happens to be handy...
		 */
		aiocbp.aio_sigevent.sigev_notify = SIGEV_CALLBACK;
		aiocbp.aio_sigevent.sigev_func = lio_async_callback_handler;
		aiocbp.aio_sigevent.sigev_value.sival_int = size;
	}
#endif
#if defined(__linux__) && !defined(__UCLIBC__)
	else if (method & LIO_WAIT_CBTYPES) {
		/* sival_int just has to be something that I can use
		 * to identify the callback, and "size" happens to be handy...
		 */
		aiocbp.aio_sigevent.sigev_notify = SIGEV_THREAD;
		aiocbp.aio_sigevent.sigev_notify_function =
		    lio_async_callback_handler;
		aiocbp.aio_sigevent.sigev_notify_attributes =
		    (void *)(uintptr_t) size;
	}
#endif
	/*
	 * Determine the system call that will be called and produce
	 * the string of the system call and place it in Lio_SysCall.
	 * Also update the io_type char pointer to give brief description
	 * of system call.  Execute the system call and check for
	 * system call failure.  If sync i/o, return the number of
	 * bytes written/read.
	 */

	if ((method & LIO_IO_SYNC)
	    || (method & (LIO_IO_TYPES | LIO_IO_ATYPES)) == 0) {
		/*
		 * write(2) is used if LIO_IO_SYNC bit is set or not none
		 * of the LIO_IO_TYPES bits are set (default).
		 */

		sprintf(Lio_SysCall, "write(%d, buf, %d)", fd, size);
		io_type = "write";

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}
		while (1) {
			if (((ret = write(fd, buffer, size)) == -1)
			    && errno != EAGAIN && errno != EINTR) {
				sprintf(Errormsg,
					"%s/%d write(%d, buf, %d) ret:-1, errno=%d %s",
					__FILE__, __LINE__, fd, size, errno,
					strerror(errno));
				return -errno;
			}

			if (ret != -1) {
				if (ret != size) {
					sprintf(Errormsg,
						"%s/%d write(%d, buf, %d) returned=%d",
						__FILE__, __LINE__,
						fd, size, ret);
					size -= ret;
					buffer += ret;
				} else {
					if (Debug_level > 1)
						printf
						    ("DEBUG %s/%d: write completed without error (ret %d)\n",
						     __FILE__, __LINE__, ret);

					return ret;
				}
			}
			wait4sync_io(fd, 0);
		}

	}

	else if (method & LIO_IO_ASYNC) {
#ifdef CRAY
		sprintf(Lio_SysCall,
			"writea(%d, buf, %d, &status, %d)", fd, size, sig);
		io_type = "writea";

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		sigoff();
		if ((ret = writea(fd, buffer, size, &status, sig)) == -1) {
			sprintf(Errormsg,
				"%s/%d writea(%d, buf, %d, &stat, %d) ret:-1, errno=%d %s",
				__FILE__, __LINE__,
				fd, size, sig, errno, strerror(errno));
			sigon();
			return -errno;
		}
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
		sprintf(Lio_SysCall,
			"aio_write(fildes=%d, buf, nbytes=%d, signo=%d)", fd,
			size, sig);
		io_type = "aio_write";

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		if (sig)
			sighold(sig);
		if ((ret = aio_write(&aiocbp)) == -1) {
			sprintf(Errormsg,
				"%s/%d aio_write(fildes=%d, buf, nbytes=%d, signo=%d) ret:-1, errno=%d %s",
				__FILE__, __LINE__,
				fd, size, sig, errno, strerror(errno));
			if (sig)
				sigrelse(sig);
			return -errno;
		}
#endif
	}
	/* LIO_IO_ASYNC */
	else if (method & LIO_IO_SLISTIO) {
#ifdef CRAY
		request.li_opcode = LO_WRITE;
		request.li_fildes = fd;
		request.li_buf = buffer;
		request.li_nbyte = size;
		request.li_status = &status;
		request.li_signo = sig;
		request.li_nstride = 0;
		request.li_filstride = 0;
		request.li_memstride = 0;

		listio_cmd = LC_WAIT;
		io_type = "listio(2) sync write";

		sprintf(Lio_SysCall,
			"listio(LC_WAIT, &req, 1) LO_WRITE, fd:%d, nbyte:%d",
			fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		sigoff();
		if (listio(listio_cmd, &request, 1) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			sigon();
			return -errno;
		}

		if (Debug_level > 1)
			printf("DEBUG %s/%d: %s did not return -1\n",
			       __FILE__, __LINE__, Lio_SysCall);

		ret = lio_check_asyncio(io_type, size, &status);
		return ret;

#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))

		aiocbp.aio_lio_opcode = LIO_WRITE;
		listio_cmd = LIO_WAIT;
		io_type = "lio_listio(3) sync write";

		sprintf(Lio_SysCall,
			"lio_listio(LIO_WAIT, aiolist, 1, NULL) LIO_WRITE, fd:%d, nbyte:%d, sig:%d",
			fd, size, sig);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		if (sig)
			sighold(sig);
		if (lio_listio(listio_cmd, aiolist, 1, NULL) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			if (sig)
				sigrelse(sig);
			return -errno;
		}

		if (Debug_level > 1)
			printf("DEBUG %s/%d: %s did not return -1\n",
			       __FILE__, __LINE__, Lio_SysCall);

		ret = lio_check_asyncio(io_type, size, &aiocbp, method);
		return ret;
#endif
	}
	/* LIO_IO_SLISTIO */
	else if (method & LIO_IO_ALISTIO) {
#ifdef CRAY
		request.li_opcode = LO_WRITE;
		request.li_fildes = fd;
		request.li_buf = buffer;
		request.li_nbyte = size;
		request.li_status = &status;
		request.li_signo = sig;
		request.li_nstride = 0;
		request.li_filstride = 0;
		request.li_memstride = 0;

		listio_cmd = LC_START;
		io_type = "listio(2) async write";

		sprintf(Lio_SysCall,
			"listio(LC_START, &req, 1) LO_WRITE, fd:%d, nbyte:%d",
			fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		sigoff();
		if (listio(listio_cmd, &request, 1) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			sigon();
			return -errno;
		}
#endif
#if defined (sgi) || (defined(__linux__) && !defined(__UCLIBC__))
		aiocbp.aio_lio_opcode = LIO_WRITE;
		listio_cmd = LIO_NOWAIT;
		io_type = "lio_listio(3) async write";

		sprintf(Lio_SysCall,
			"lio_listio(LIO_NOWAIT, aiolist, 1, NULL) LIO_WRITE, fd:%d, nbyte:%d",
			fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		if (sig)
			sighold(sig);
		if (lio_listio(listio_cmd, aiolist, 1, NULL) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			if (sig)
				sigrelse(sig);
			return -errno;
		}
#endif
	}
	/* LIO_IO_ALISTIO */
#ifndef CRAY
	else if (method & LIO_IO_SYNCV) {
		io_type = "writev(2)";

		sprintf(Lio_SysCall, "writev(%d, &iov, 1) nbyte:%d", fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}
		if ((ret = writev(fd, &iov, 1)) == -1) {
			sprintf(Errormsg,
				"%s/%d writev(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
				__FILE__, __LINE__, fd, size, errno,
				strerror(errno));
			return -errno;
		}

		if (ret != size) {
			sprintf(Errormsg,
				"%s/%d writev(%d, iov, 1) nbyte:%d returned=%d",
				__FILE__, __LINE__, fd, size, ret);
		} else if (Debug_level > 1)
			printf
			    ("DEBUG %s/%d: writev completed without error (ret %d)\n",
			     __FILE__, __LINE__, ret);

		return ret;
	}			/* LIO_IO_SYNCV */
#endif

#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	else if (method & LIO_IO_SYNCP) {
		io_type = "pwrite(2)";

		sprintf(Lio_SysCall,
			"pwrite(%d, buf, %d, %lld)", fd, size,
			(long long)poffset);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}
		if ((ret = pwrite(fd, buffer, size, poffset)) == -1) {
			sprintf(Errormsg,
				"%s/%d pwrite(%d, buf, %d, %lld) ret:-1, errno=%d %s",
				__FILE__, __LINE__, fd, size,
				(long long)poffset, errno, strerror(errno));
			return -errno;
		}

		if (ret != size) {
			sprintf(Errormsg,
				"%s/%d pwrite(%d, buf, %d, %lld) returned=%d",
				__FILE__, __LINE__,
				fd, size, (long long)poffset, ret);
		} else if (Debug_level > 1)
			printf
			    ("DEBUG %s/%d: pwrite completed without error (ret %d)\n",
			     __FILE__, __LINE__, ret);

		return ret;
	}			/* LIO_IO_SYNCP */
#endif

	else {
		printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__,
		       __LINE__);
		return -1;
	}

	/*
	 * wait for async io to complete.
	 */
#ifdef CRAY
	ret = lio_wait4asyncio(method, fd, statptr);
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	ret = lio_wait4asyncio(method, fd, &aiocbp);
#endif

	/*
	 * If there was an error waiting for async i/o to complete,
	 * return the error value (errno) to the caller.
	 * Note: Errormsg should already have been updated.
	 */
	if (ret < 0) {
		return ret;
	}

	/*
	 * If i/o was not waited for (may not have been completed at this time),
	 * return the size that was requested.
	 */
	if (ret == 1)
		return size;

	/*
	 * check that async io was successful.
	 * Note:  if the there was an system call failure, -errno
	 * was returned and Errormsg should already have been updated.
	 * If amount i/o was different than size, Errormsg should already
	 * have been updated but the actual i/o size if returned.
	 */

#ifdef CRAY
	ret = lio_check_asyncio(io_type, size, &status);
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	ret = lio_check_asyncio(io_type, size, &aiocbp, method);
#endif

	return ret;
}				/* end of lio_write_buffer */

/***********************************************************************
 * Generic read function
 * This function can be used to do a read using read(2), reada(2),
 * aio_read(3), readv(2), pread(2),
 * or single stride listio(2)/lio_listio(3).
 * By setting the desired bits in the method
 * bitmask, the caller can control the type of read and the wait method
 * that will be used.  If no io type bits are set, read will be used.
 *
 * If async io was attempted and no wait method bits are set then the
 * wait method is: recall(2) for reada(2) and listio(2); aio_suspend(3) for
 * aio_read(3) and lio_listio(3).
 *
 * If multiple wait methods are specified,
 * only one wait method will be used. The order is predetermined.
 *
 * If the call specifies a signal and one of the two signal wait methods,
 * a signal handler for the signal is set.  This will reset an already
 * set handler for this signal.
 *
 * If the LIO_RANDOM method bit is set, this function will randomly
 * choose a io type and wait method from bits in the method argument.
 *
 * If an error is encountered, an error message will be generated
 * in a internal static buffer.  If errmsg is not NULL, it will
 * be updated to point to the static buffer, allowing the caller
 * to print the error message.
 *
 * Return Value
 *   If a system call fails, -errno is returned.
 *   If LIO_WAIT_NONE bit is set, the return value is the return value
 *   of the system call.
 *   If the io did not fail, the amount of data written is returned.
 *	If the size the system call say was written is different
 *	then what was asked to be written, errmsg is updated for
 *	this error condition.  The return value is still the amount
 *	the system call says was written.
 *
 * (rrl 04/96)
 ***********************************************************************/
int lio_read_buffer(fd, method, buffer, size, sig, errmsg, wrd)
int fd;				/* open file descriptor */
int method;			/* contains io type and wait method bitmask */
char *buffer;			/* pointer to buffer */
int size;			/* the size of the io */
int sig;			/* signal to use if async io */
char **errmsg;			/* char pointer that will be updated to point to err message */
long wrd;			/* to allow future features, use zero for now */
{
	int ret = 0;		/* syscall return or used to get random method */
	char *io_type;		/* Holds string of type of io */
	int listio_cmd;		/* Holds the listio/lio_listio cmd */
	int omethod = method;
#ifdef  CRAY
	struct listreq request;	/* Used when a listio is wanted */
	struct iosw status, *statptr[1];
#else
	/* for linux or sgi */
	struct iovec iov;	/* iovec for readv(2) */
#endif
#ifdef sgi
	aiocb_t aiocbp;		/* POSIX aio control block */
	aiocb_t *aiolist[1];	/* list of aio control blocks for lio_listio */
	off64_t poffset;	/* pread(2) offset */
#endif
#if defined (__linux__) && !defined(__UCLIBC__)
	struct aiocb aiocbp;	/* POSIX aio control block */
	struct aiocb *aiolist[1];	/* list of aio control blocks for lio_listio */
	off64_t poffset;	/* pread(2) offset */
#endif

	/*
	 * If LIO_RANDOM bit specified, get new method randomly.
	 */
	if (method & LIO_RANDOM) {
		if (Debug_level > 3)
			printf("DEBUG %s/%d: method mask to choose from: %#o\n",
			       __FILE__, __LINE__, method);
		method = lio_random_methods(method);
		if (Debug_level > 2)
			printf("DEBUG %s/%d: random chosen method %#o\n",
			       __FILE__, __LINE__, method);
	}

	if (errmsg != NULL)
		*errmsg = Errormsg;

	Rec_signal = Received_signal;	/* get the current number of signals received */
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	Rec_callback = Received_callback;	/* get the current number of callbacks received */
#endif

#ifdef  CRAY
	memset(&status, 0x00, sizeof(struct iosw));
	memset(&request, 0x00, sizeof(struct listreq));
	statptr[0] = &status;
#else
	/* for linux or sgi */
	memset(&iov, 0x00, sizeof(struct iovec));
	iov.iov_base = buffer;
	iov.iov_len = size;
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
#if defined(sgi)
	memset(&aiocbp, 0x00, sizeof(aiocb_t));
#else
	memset(&aiocbp, 0x00, sizeof(struct aiocb));
#endif
	aiocbp.aio_fildes = fd;
	aiocbp.aio_nbytes = size;
	aiocbp.aio_buf = buffer;
/*    aiocbp.aio_offset = lseek( fd, 0, SEEK_CUR ); -- set below */
	aiocbp.aio_sigevent.sigev_notify = SIGEV_NONE;
	aiocbp.aio_sigevent.sigev_signo = 0;
#ifdef sgi
	aiocbp.aio_sigevent.sigev_func = NULL;
	aiocbp.aio_sigevent.sigev_value.sival_int = 0;
#elif defined(__linux__) && !defined(__UCLIBC__)
	aiocbp.aio_sigevent.sigev_notify_function = NULL;
	aiocbp.aio_sigevent.sigev_notify_attributes = 0;
#endif
	aiolist[0] = &aiocbp;

	if ((ret = lseek(fd, 0, SEEK_CUR)) == -1) {
		ret = 0;
		/* If there is an error and it is not ESPIPE then kick out the error.
		 * If the fd is a fifo then we have to make sure that
		 * lio_random_methods() didn't select pwrite/pread; if it did then
		 * switch to write/read.
		 */
		if (errno == ESPIPE) {
			if (method & LIO_IO_SYNCP) {
				if (omethod & LIO_RANDOM) {
					method &= ~LIO_IO_SYNCP;
					method |= LIO_IO_SYNC;
					if (Debug_level > 2)
						printf
						    ("DEBUG %s/%d: random chosen method switched to %#o for fifo\n",
						     __FILE__, __LINE__,
						     method);
				} else if (Debug_level) {
					printf
					    ("DEBUG %s/%d: pread will fail when it reads from a fifo\n",
					     __FILE__, __LINE__);
				}
			}
			/* else: let it ride */
		} else {
			sprintf(Errormsg,
				"%s/%d lseek(fd=%d,0,SEEK_CUR) failed, errno=%d  %s",
				__FILE__, __LINE__, fd, errno, strerror(errno));
			return -errno;
		}
	}
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	poffset = (off64_t) ret;
#endif
	aiocbp.aio_offset = ret;

#endif

	/*
	 * If the LIO_USE_SIGNAL bit is not set, only use the signal
	 * if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are set.
	 * Otherwise there is not necessarily a signal handler to trap
	 * the signal.
	 */
	if (sig && !(method & LIO_USE_SIGNAL) && !(method & LIO_WAIT_SIGTYPES)) {

		sig = 0;	/* ignore signal parameter */
	}
#if defined(sgi) || (defined(__linux__)&& !defined(__UCLIBC__))
	if (sig && (method & LIO_WAIT_CBTYPES))
		sig = 0;	/* ignore signal parameter */
#endif

	/*
	 * only setup signal hander if sig was specified and
	 * a sig wait method was specified.
	 * Doing this will change the handler for this signal.  The
	 * old signal handler will not be restored.
	 *** restoring the signal handler could be added ***
	 */

	if (sig && (method & LIO_WAIT_SIGTYPES)) {
#ifdef CRAY
		sigctl(SCTL_REG, sig, lio_async_signal_handler);
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
		aiocbp.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
		aiocbp.aio_sigevent.sigev_signo = sig;
		sigset(sig, lio_async_signal_handler);
#endif /* CRAY */
	}
#if defined(sgi)
	else if (method & LIO_WAIT_CBTYPES) {
		aiocbp.aio_sigevent.sigev_notify = SIGEV_CALLBACK;
		aiocbp.aio_sigevent.sigev_func = lio_async_callback_handler;
		/* sival_int just has to be something that I can use
		 * to identify the callback, and "size" happens to be handy...
		 */
		aiocbp.aio_sigevent.sigev_value.sival_int = size;
	}
#endif
#if defined(__linux__) && !defined(__UCLIBC__)
	else if (method & LIO_WAIT_CBTYPES) {
		aiocbp.aio_sigevent.sigev_notify = SIGEV_THREAD;
		aiocbp.aio_sigevent.sigev_notify_function =
		    lio_async_callback_handler;
		/* sival_int just has to be something that I can use
		 * to identify the callback, and "size" happens to be handy...
		 */
		aiocbp.aio_sigevent.sigev_notify_attributes =
		    (void *)(uintptr_t) size;
	}
#endif

	/*
	 * Determine the system call that will be called and produce
	 * the string of the system call and place it in Lio_SysCall.
	 * Also update the io_type char pointer to give brief description
	 * of system call.  Execute the system call and check for
	 * system call failure.  If sync i/o, return the number of
	 * bytes written/read.
	 */

	if ((method & LIO_IO_SYNC)
	    || (method & (LIO_IO_TYPES | LIO_IO_ATYPES)) == 0) {
		/*
		 * read(2) is used if LIO_IO_SYNC bit is set or not none
		 * of the LIO_IO_TYPES bits are set (default).
		 */

		sprintf(Lio_SysCall, "read(%d, buf, %d)", fd, size);
		io_type = "read";

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		while (1) {
			if (((ret = read(fd, buffer, size)) == -1)
			    && errno != EINTR && errno != EAGAIN) {
				sprintf(Errormsg,
					"%s/%d read(%d, buf, %d) ret:-1, errno=%d %s",
					__FILE__, __LINE__, fd, size, errno,
					strerror(errno));
				return -errno;
			}

			if (ret == 0)
				return 0;
			if (ret != -1) {
				if (ret != size) {
					sprintf(Errormsg,
						"%s/%d read(%d, buf, %d) returned=%d",
						__FILE__, __LINE__,
						fd, size, ret);
					size -= ret;
					buffer += ret;
				} else {
					if (Debug_level > 1)
						printf
						    ("DEBUG %s/%d: read completed without error (ret %d)\n",
						     __FILE__, __LINE__, ret);

					return ret;
				}
			}
			wait4sync_io(fd, 1);
		}

	}

	else if (method & LIO_IO_ASYNC) {
#ifdef CRAY
		sprintf(Lio_SysCall,
			"reada(%d, buf, %d, &status, %d)", fd, size, sig);
		io_type = "reada";

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		sigoff();
		if ((ret = reada(fd, buffer, size, &status, sig)) == -1) {
			sprintf(Errormsg,
				"%s/%d reada(%d, buf, %d, &stat, %d) ret:-1, errno=%d %s",
				__FILE__, __LINE__,
				fd, size, sig, errno, strerror(errno));
			sigon();
			return -errno;
		}
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
		sprintf(Lio_SysCall,
			"aio_read(fildes=%d, buf, nbytes=%d, signo=%d)", fd,
			size, sig);
		io_type = "aio_read";

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		if (sig)
			sighold(sig);
		if ((ret = aio_read(&aiocbp)) == -1) {
			sprintf(Errormsg,
				"%s/%d aio_read(fildes=%d, buf, nbytes=%d, signo=%d) ret:-1, errno=%d %s",
				__FILE__, __LINE__,
				fd, size, sig, errno, strerror(errno));
			if (sig)
				sigrelse(sig);
			return -errno;
		}
#endif
	}
	/* LIO_IO_ASYNC */
	else if (method & LIO_IO_SLISTIO) {
#ifdef CRAY
		request.li_opcode = LO_READ;
		request.li_fildes = fd;
		request.li_buf = buffer;
		request.li_nbyte = size;
		request.li_status = &status;
		request.li_signo = sig;
		request.li_nstride = 0;
		request.li_filstride = 0;
		request.li_memstride = 0;

		listio_cmd = LC_WAIT;
		io_type = "listio(2) sync read";

		sprintf(Lio_SysCall,
			"listio(LC_WAIT, &req, 1) LO_READ, fd:%d, nbyte:%d",
			fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		sigoff();
		if (listio(listio_cmd, &request, 1) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			sigon();
			return -errno;
		}

		if (Debug_level > 1)
			printf("DEBUG %s/%d: %s did not return -1\n",
			       __FILE__, __LINE__, Lio_SysCall);

		ret = lio_check_asyncio(io_type, size, &status);
		return ret;
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
		aiocbp.aio_lio_opcode = LIO_READ;
		listio_cmd = LIO_WAIT;
		io_type = "lio_listio(3) sync read";

		sprintf(Lio_SysCall,
			"lio_listio(LIO_WAIT, aiolist, 1, NULL) LIO_READ, fd:%d, nbyte:%d",
			fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		if (sig)
			sighold(sig);
		if (lio_listio(listio_cmd, aiolist, 1, NULL) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			if (sig)
				sigrelse(sig);
			return -errno;
		}

		if (Debug_level > 1)
			printf("DEBUG %s/%d: %s did not return -1\n",
			       __FILE__, __LINE__, Lio_SysCall);

		ret = lio_check_asyncio(io_type, size, &aiocbp, method);
		return ret;
#endif
	}
	/* LIO_IO_SLISTIO */
	else if (method & LIO_IO_ALISTIO) {
#ifdef CRAY
		request.li_opcode = LO_READ;
		request.li_fildes = fd;
		request.li_buf = buffer;
		request.li_nbyte = size;
		request.li_status = &status;
		request.li_signo = sig;
		request.li_nstride = 0;
		request.li_filstride = 0;
		request.li_memstride = 0;

		listio_cmd = LC_START;
		io_type = "listio(2) async read";

		sprintf(Lio_SysCall,
			"listio(LC_START, &req, 1) LO_READ, fd:%d, nbyte:%d",
			fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		sigoff();
		if (listio(listio_cmd, &request, 1) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			sigon();
			return -errno;
		}
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
		aiocbp.aio_lio_opcode = LIO_READ;
		listio_cmd = LIO_NOWAIT;
		io_type = "lio_listio(3) async read";

		sprintf(Lio_SysCall,
			"lio_listio(LIO_NOWAIT, aiolist, 1, NULL) LIO_READ, fd:%d, nbyte:%d",
			fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}

		if (sig)
			sighold(sig);
		if (lio_listio(listio_cmd, aiolist, 1, NULL) == -1) {
			sprintf(Errormsg,
				"%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
				__FILE__, __LINE__, Lio_SysCall, fd, size,
				errno, strerror(errno));
			if (sig)
				sigrelse(sig);
			return -errno;
		}
#endif
	}
	/* LIO_IO_ALISTIO */
#ifndef CRAY
	else if (method & LIO_IO_SYNCV) {
		io_type = "readv(2)";

		sprintf(Lio_SysCall, "readv(%d, &iov, 1) nbyte:%d", fd, size);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}
		if ((ret = readv(fd, &iov, 1)) == -1) {
			sprintf(Errormsg,
				"%s/%d readv(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
				__FILE__, __LINE__, fd, size, errno,
				strerror(errno));
			return -errno;
		}

		if (ret != size) {
			sprintf(Errormsg,
				"%s/%d readv(%d, iov, 1) nbyte:%d returned=%d",
				__FILE__, __LINE__, fd, size, ret);
		} else if (Debug_level > 1)
			printf
			    ("DEBUG %s/%d: readv completed without error (ret %d)\n",
			     __FILE__, __LINE__, ret);

		return ret;
	}			/* LIO_IO_SYNCV */
#endif

#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	else if (method & LIO_IO_SYNCP) {
		io_type = "pread(2)";

		sprintf(Lio_SysCall,
			"pread(%d, buf, %d, %lld)", fd, size,
			(long long)poffset);

		if (Debug_level) {
			printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__,
			       Lio_SysCall);
		}
		if ((ret = pread(fd, buffer, size, poffset)) == -1) {
			sprintf(Errormsg,
				"%s/%d pread(%d, buf, %d, %lld) ret:-1, errno=%d %s",
				__FILE__, __LINE__, fd, size,
				(long long)poffset, errno, strerror(errno));
			return -errno;
		}

		if (ret != size) {
			sprintf(Errormsg,
				"%s/%d pread(%d, buf, %d, %lld) returned=%d",
				__FILE__, __LINE__,
				fd, size, (long long)poffset, ret);
		} else if (Debug_level > 1)
			printf
			    ("DEBUG %s/%d: pread completed without error (ret %d)\n",
			     __FILE__, __LINE__, ret);

		return ret;
	}			/* LIO_IO_SYNCP */
#endif

	else {
		printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__,
		       __LINE__);
		return -1;
	}

	/*
	 * wait for async io to complete.
	 * Note: Sync io should have returned prior to getting here.
	 */
#ifdef CRAY
	ret = lio_wait4asyncio(method, fd, statptr);
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	ret = lio_wait4asyncio(method, fd, &aiocbp);
#endif

	/*
	 * If there was an error waiting for async i/o to complete,
	 * return the error value (errno) to the caller.
	 * Note: Errormsg should already have been updated.
	 */
	if (ret < 0) {
		return ret;
	}

	/*
	 * If i/o was not waited for (may not have been completed at this time),
	 * return the size that was requested.
	 */
	if (ret == 1)
		return size;

	/*
	 * check that async io was successful.
	 * Note:  if the there was an system call failure, -errno
	 * was returned and Errormsg should already have been updated.
	 * If amount i/o was different than size, Errormsg should already
	 * have been updated but the actual i/o size if returned.
	 */

#ifdef CRAY
	ret = lio_check_asyncio(io_type, size, &status);
#endif
#if defined(sgi) || (defined(__linux__) && !defined(__UCLIBC__))
	ret = lio_check_asyncio(io_type, size, &aiocbp, method);
#endif

	return ret;
}				/* end of lio_read_buffer */

#if !defined(__sun) && !defined(__hpux) && !defined(_AIX)
/***********************************************************************
 * This function will check that async io was successful.
 * It can also be used to check sync listio since it uses the
 * same method.
 *
 * Return Values
 *  If status.sw_error is set, -status.sw_error is returned.
 *  Otherwise sw_count's field value is returned.
 *
 * (rrl 04/96)
 ***********************************************************************/
#ifdef CRAY
int lio_check_asyncio(char *io_type, int size, struct iosw *status)
#elif defined(sgi)
int lio_check_asyncio(char *io_type, int size, aiocb_t * aiocbp, int method)
#elif defined(__linux__) && !defined(__UCLIBC__)
int lio_check_asyncio(char *io_type, int size, struct aiocb *aiocbp, int method)
{
	int ret;

#ifdef CRAY
	if (status->sw_error) {
		sprintf(Errormsg,
			"%s/%d %s, sw_error set = %d %s, sw_count = %d",
			__FILE__, __LINE__, io_type,
			status->sw_error, strerror(status->sw_error),
			status->sw_count);
		return -status->sw_error;
	} else if (status->sw_count != size) {
		sprintf(Errormsg,
			"%s/%d %s, sw_count not as expected(%d), but actual:%d",
			__FILE__, __LINE__, io_type, size, status->sw_count);
	} else if (Debug_level > 1) {
		printf
		    ("DEBUG %s/%d: %s completed without error (sw_error == 0, sw_count == %d)\n",
		     __FILE__, __LINE__, io_type, status->sw_count);
	}

	return status->sw_count;

#else

	int cnt = 1;

	/* The I/O may have been synchronous with signal completion.  It doesn't
	 * make sense, but the combination could be generated.  Release the
	 * completion signal here otherwise it'll hang around and bite us
	 * later.
	 */
	if (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL)
		sigrelse(aiocbp->aio_sigevent.sigev_signo);

	ret = aio_error(aiocbp);

	while (ret == EINPROGRESS) {
		ret = aio_error(aiocbp);
		++cnt;
	}
	if (cnt > 1) {
		sprintf(Errormsg,
			"%s/%d %s, aio_error had to loop on EINPROGRESS, cnt=%d; random method %#o; sigev_notify=%s",
			__FILE__, __LINE__, io_type, cnt, method,
			(aiocbp->aio_sigevent.sigev_notify ==
			 SIGEV_SIGNAL ? "signal" : aiocbp->aio_sigevent.
			 sigev_notify == SIGEV_NONE ? "none" :
#ifdef SIGEV_CALLBACK
			 aiocbp->aio_sigevent.sigev_notify ==
			 SIGEV_CALLBACK ? "callback" :
#endif
			 aiocbp->aio_sigevent.sigev_notify ==
			 SIGEV_THREAD ? "thread" : "unknown"));
		return -ret;
	}

	if (ret != 0) {
		sprintf(Errormsg,
			"%s/%d %s, aio_error = %d %s; random method %#o",
			__FILE__, __LINE__, io_type,
			ret, strerror(ret), method);
		return -ret;
	}
	ret = aio_return(aiocbp);
	if (ret != size) {
		sprintf(Errormsg,
			"%s/%d %s, aio_return not as expected(%d), but actual:%d",
			__FILE__, __LINE__, io_type, size, ret);

#ifdef BUG1_workaround
		if (ret == 0) {
			ret = size;
			if (Debug_level > 1) {
				printf
				    ("WARN %s/%d: %s completed with bug1_workaround (aio_error == 0, aio_return now == %d)\n",
				     __FILE__, __LINE__, io_type, ret);
			}
		}
#endif /* BUG1_workaround */

	} else if (Debug_level > 1) {
		printf
		    ("DEBUG %s/%d: %s completed without error (aio_error == 0, aio_return == %d)\n",
		     __FILE__, __LINE__, io_type, ret);
	}

	return ret;

#endif
}				/* end of lio_check_asyncio */
#endif

/***********************************************************************
 *
 * This function will wait for async io to complete.
 * If multiple wait methods are specified, the order is predetermined
 * to LIO_WAIT_RECALL,
 * LIO_WAIT_ACTIVE, LIO_WAIT_SIGPAUSE, LIO_WAIT_SIGACTIVE,
 * then LIO_WAIT_NONE.
 *
 * If no wait method was specified the default wait method is: recall(2)
 * or aio_suspend(3), as appropriate.
 *
 * Return Values
 *	<0: errno of failed recall
 *	0 : async io was completed
 *	1 : async was not waited for, io may not have completed.
 *
 * (rrl 04/96)
 ***********************************************************************/
#ifdef CRAY
int lio_wait4asyncio(int method, int fd, struct iosw **statptr)
#elif defined(sgi)
int lio_wait4asyncio(int method, int fd, aiocb_t * aiocbp)
#elif defined(__linux__) && !defined(__UCLIBC__)
int lio_wait4asyncio(int method, int fd, struct aiocb *aiocbp)
{
	int cnt;
#ifdef sgi
	int ret;
	const aiocb_t *aioary[1];
#endif
#if defined(__linux__)&& !defined(__UCLIBC__)
	int ret;
	const struct aiocb *aioary[1];
#endif

	if ((method & LIO_WAIT_RECALL)
#if defined(sgi) || (defined(__linux__)&& !defined(__UCLIBC__))
	    || (method & LIO_WAIT_CBSUSPEND)
	    || (method & LIO_WAIT_SIGSUSPEND)
#endif
	    || ((method & LIO_WAIT_TYPES) == 0)) {
		/*
		 * If method has LIO_WAIT_RECALL bit set or method does
		 * not have any wait method bits set (default), use recall/aio_suspend.
		 */
#ifdef CRAY
		if (Debug_level > 2)
			printf("DEBUG %s/%d: wait method : recall\n", __FILE__,
			       __LINE__);
		sigon();
		if (recall(fd, 1, statptr)) {
			sprintf(Errormsg,
				"%s/%d recall(%d, 1, stat) failed, errno:%d %s",
				__FILE__, __LINE__, fd, errno, strerror(errno));
			return -errno;
		}
#else
		if (Debug_level > 2)
			printf
			    ("DEBUG %s/%d: wait method : aio_suspend, sigev_notify=%s\n",
			     __FILE__, __LINE__,
			     (aiocbp->aio_sigevent.sigev_notify ==
			      SIGEV_SIGNAL ? "signal" : aiocbp->aio_sigevent.
			      sigev_notify == SIGEV_NONE ? "none" :
#ifdef SIGEV_CALLBACK
			      aiocbp->aio_sigevent.sigev_notify ==
			      SIGEV_CALLBACK ? "callback" :
#endif
			      aiocbp->aio_sigevent.sigev_notify ==
			      SIGEV_THREAD ? "thread" : "unknown"));

		aioary[0] = aiocbp;
		ret = aio_suspend(aioary, 1, NULL);
		if ((ret == -1) && (errno == EINTR)) {
			if (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL) {
				if (Debug_level > 2) {
					printf
					    ("DEBUG %s/%d: aio_suspend received EINTR, sigev_notify=SIGEV_SIGNAL -- ok\n",
					     __FILE__, __LINE__);
				}
			} else {
				sprintf(Errormsg,
					"%s/%d aio_suspend received EINTR, sigev_notify=%s, not ok\n",
					__FILE__, __LINE__,
					(aiocbp->aio_sigevent.sigev_notify ==
					 SIGEV_SIGNAL ? "signal" : aiocbp->
					 aio_sigevent.sigev_notify ==
					 SIGEV_NONE ? "none" :
#ifdef SIGEV_CALLBACK
					 aiocbp->aio_sigevent.sigev_notify ==
					 SIGEV_CALLBACK ? "callback" :
#endif
					 aiocbp->aio_sigevent.sigev_notify ==
					 SIGEV_THREAD ? "thread" : "unknown"));
				return -errno;
			}
		} else if (ret) {
			sprintf(Errormsg,
				"%s/%d aio_suspend(fildes=%d, aioary, 1, NULL) failed, errno:%d %s",
				__FILE__, __LINE__, fd, errno, strerror(errno));
			return -errno;
		}
#endif

	} else if (method & LIO_WAIT_ACTIVE) {
		if (Debug_level > 2)
			printf("DEBUG %s/%d: wait method : active\n", __FILE__,
			       __LINE__);
#ifdef CRAY
		sigon();
		/*
		 * loop until sw_flag, sw_count or sw_error field elements
		 * change to non-zero.
		 */
		cnt = 0;
		while ((*statptr)->sw_flag == 0 &&
		       (*statptr)->sw_count == 0 && (*statptr)->sw_error == 0) {
			cnt++;
		}
#else
		/* loop while aio_error() returns EINPROGRESS */
		cnt = 0;
		while (1) {
			ret = aio_error(aiocbp);
			if ((ret == 0) || (ret != EINPROGRESS)) {
				break;
			}
			++cnt;
		}

#endif
		if (Debug_level > 5 && cnt && (cnt % 50) == 0)
			printf("DEBUG %s/%d: wait active cnt = %d\n",
			       __FILE__, __LINE__, cnt);

	} else if (method & LIO_WAIT_SIGPAUSE) {
		if (Debug_level > 2)
			printf("DEBUG %s/%d: wait method : sigpause\n",
			       __FILE__, __LINE__);
#ifdef sgi
		/* note: don't do the sigon() for CRAY in this case.  why? -- roehrich 6/11/97 */
		if (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL)
			sigrelse(aiocbp->aio_sigevent.sigev_signo);
		else {
			printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n",
			       __FILE__, __LINE__);
			return -1;
		}
#endif
		pause();

	} else if (method & LIO_WAIT_SIGACTIVE) {
		if (Debug_level > 2)
			printf("DEBUG %s/%d: wait method : sigactive\n",
			       __FILE__, __LINE__);
#ifdef CRAY
		sigon();
#else
		if (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL)
			sigrelse(aiocbp->aio_sigevent.sigev_signo);
		else {
			printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n",
			       __FILE__, __LINE__);
			return -1;
		}
#endif
		/* loop waiting for signal */
		while (Received_signal == Rec_signal) {
#ifdef CRAY
			sigon();
#else
			sigrelse(aiocbp->aio_sigevent.sigev_signo);
#endif
		}

	} else if (method & LIO_WAIT_NONE) {
		if (Debug_level > 2)
			printf("DEBUG %s/%d: wait method : none\n", __FILE__,
			       __LINE__);
		/* It's broken because the aiocb/iosw is an automatic variable in
		 * lio_{read,write}_buffer, so when the function returns and the
		 * I/O completes there will be nowhere to write the I/O status.
		 * It doesn't cause a problem on unicos--probably because of some
		 * compiler quirk, or an accident.  It causes POSIX async I/O
		 * to core dump some threads.   spr/pv 705909.  6/27/97 roehrich
		 */
		sprintf(Errormsg,
			"%s/%d LIO_WAIT_NONE was selected (this is broken)\n",
			__FILE__, __LINE__);
#ifdef CRAY
		sigon();
#endif
/*        return 1;*/
		return -1;
	} else {
		if (Debug_level > 2)
			printf("DEBUG %s/%d: no wait method was chosen\n",
			       __FILE__, __LINE__);
		return -1;
	}

	return 0;

}				/* end of lio_wait4asyncio */

#endif /* ifndef linux */
#endif

#if UNIT_TEST
/***********************************************************************
 * The following code is provided as unit test.
 * Just define add "-DUNIT_TEST=1" to the cc line.
 *
 * (rrl 04/96)
 ***********************************************************************/
struct unit_info_t {
	int method;
	int sig;
	char *str;
} Unit_info[] = {
	{
	LIO_IO_SYNC, 0, "sync io"}, {
	LIO_IO_SYNCV, 0, "sync readv/writev"}, {
	LIO_IO_SYNCP, 0, "sync pread/pwrite"}, {
	LIO_IO_ASYNC, 0, "async io, def wait"}, {
	LIO_IO_SLISTIO, 0, "sync listio"}, {
	LIO_IO_ALISTIO, 0, "async listio, def wait"}, {
	LIO_IO_ASYNC | LIO_WAIT_ACTIVE, 0, "async active"}, {
	LIO_IO_ASYNC | LIO_WAIT_RECALL, 0, "async recall/suspend"}, {
	LIO_IO_ASYNC | LIO_WAIT_SIGPAUSE, SIGUSR1, "async sigpause"}, {
	LIO_IO_ASYNC | LIO_WAIT_SIGACTIVE, SIGUSR1, "async sigactive"}, {
	LIO_IO_ALISTIO | LIO_WAIT_ACTIVE, 0, "async listio active"}, {
	LIO_IO_ALISTIO | LIO_WAIT_RECALL, 0, "async listio recall"}, {
	LIO_IO_ALISTIO | LIO_WAIT_SIGACTIVE, SIGUSR1, "async listio sigactive"},
	{
	LIO_IO_ALISTIO | LIO_WAIT_SIGPAUSE, SIGUSR1, "async listio sigpause"},
	{
	LIO_IO_ASYNC, SIGUSR2, "async io, def wait, sigusr2"}, {
LIO_IO_ALISTIO, SIGUSR2, "async listio, def wait, sigusr2"},};

int main(argc, argv)
int argc;
char **argv;
{
	extern char *optarg;
	extern int optind;

	int fd;
	char *err;
	char buffer[4096];
	int size = 4096;
	int ret;
	int ind;
	int iter = 3;
	int method;
	int exit_status = 0;
	int c;
	int i;
	char *symbols = NULL;
	int die_on_err = 0;

	while ((c = getopt(argc, argv, "s:di:")) != -1) {
		switch (c) {
		case 's':
			symbols = optarg;
			break;
		case 'd':
			++die_on_err;
			break;
		case 'i':
			iter = atoi(optarg);
			break;
		}
	}

	if ((fd =
	     open("unit_test_file", O_CREAT | O_RDWR | O_TRUNC, 0777)) == -1) {
		perror
		    ("open(unit_test_file, O_CREAT|O_RDWR|O_TRUNC, 0777) failed");
		exit(1);
	}

	Debug_level = 9;

	if (symbols != NULL) {
		if ((method = lio_parse_io_arg2(symbols, &err)) == -1) {
			printf
			    ("lio_parse_io_arg2(%s, &err) failed, bad token starting at %s\n",
			     symbols, err);
			if (die_on_err)
				exit(1);
		} else
			printf("lio_parse_io_arg2(%s, &err) returned %#o\n",
			       symbols, method);

		exit_status = 0;
		for (ind = 0; ind < iter; ind++) {
			memset(buffer, 'A', 4096);
			if (lseek(fd, 0, 0) == -1) {
				printf("lseek(fd,0,0), %d, failed, errno %d\n",
				       __LINE__, errno);
				++exit_status;
			}
			if ((ret = lio_write_buffer(fd, method, buffer,
						    size, SIGUSR1, &err,
						    0)) != size) {
				printf
				    ("lio_write_buffer returned -1, err = %s\n",
				     err);
			} else
				printf("lio_write_buffer returned %d\n", ret);

			memset(buffer, 'B', 4096);
			if (lseek(fd, 0, 0) == -1) {
				printf("lseek(fd,0,0), %d, failed, errno %d\n",
				       __LINE__, errno);
				++exit_status;
			}
			if ((ret = lio_read_buffer(fd, method, buffer,
						   size, SIGUSR2, &err,
						   0)) != size) {
				printf
				    ("lio_read_buffer returned -1, err = %s\n",
				     err);
			} else
				printf("lio_read_buffer returned %d\n", ret);

			for (i = 0; i < 4096; ++i) {
				if (buffer[i] != 'A') {
					printf("  buffer[%d] = %d\n", i,
					       buffer[i]);
					++exit_status;
					break;
				}
			}

			if (exit_status)
				exit(exit_status);

		}

		unlink("unit_test_file");
		exit(0);
	}

	for (ind = 0; ind < sizeof(Unit_info) / sizeof(struct unit_info_t);
	     ind++) {

		printf("\n********* write %s ***************\n",
		       Unit_info[ind].str);
		if (lseek(fd, 0, 0) == -1) {
			printf("lseek(fd,0,0), %d, failed, errno %d\n",
			       __LINE__, errno);
			++exit_status;
		}

		memset(buffer, 'A', 4096);
		if ((ret = lio_write_buffer(fd, Unit_info[ind].method, buffer,
					    size, Unit_info[ind].sig, &err,
					    0)) != size) {
			printf
			    (">>>>> lio_write_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n   err = %s\n",
			     Unit_info[ind].method, size, Unit_info[ind].sig,
			     err);
			++exit_status;
			if (die_on_err)
				exit(exit_status);
		} else {
			printf("lio_write_buffer returned %d\n", ret);
		}

		printf("\n********* read %s ***************\n",
		       Unit_info[ind].str);
		if (lseek(fd, 0, 0) == -1) {
			printf("lseek(fd,0,0), %d, failed, errno %d\n",
			       __LINE__, errno);
			++exit_status;
		}
		memset(buffer, 'B', 4096);
		if ((ret = lio_read_buffer(fd, Unit_info[ind].method, buffer,
					   size, Unit_info[ind].sig, &err,
					   0)) != size) {
			printf
			    (">>>>> lio_read_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n   err = %s\n",
			     Unit_info[ind].method, size, Unit_info[ind].sig,
			     err);
			++exit_status;
			if (die_on_err)
				exit(exit_status);
		} else {
			printf("lio_read_buffer returned %d\n", ret);
		}

		for (i = 0; i < 4096; ++i) {
			if (buffer[i] != 'A') {
				printf("  buffer[%d] = %d\n", i, buffer[i]);
				++exit_status;
				if (die_on_err)
					exit(exit_status);
				break;
			}
		}

		fflush(stdout);
		fflush(stderr);
		sleep(1);

	}

	unlink("unit_test_file");

	exit(exit_status);
}
#endif