// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2000 Silicon Graphics, Inc.
 * All Rights Reserved.
 */
/*
 *
 * 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);
 *  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
 *
 */

#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 <sys/uio.h> /* readv(2)/writev(2) */
#include <string.h>
#include <strings.h>
#include <stdlib.h> /* atoi, abs */

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

#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


#ifndef linux
static void lio_async_signal_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" },
    { "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" },
    { "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;
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(int 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)
{
    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)
{
    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;
   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)
{
    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;
}

#ifndef linux
/***********************************************************************
 * 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;
}
#endif

/***********************************************************************
 * 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;
    long random_bit(long);

    /* 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;
}

/***********************************************************************
 * 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 */
#ifndef linux
    int omethod = method;
    int listio_cmd;		/* Holds the listio/lio_listio cmd */
#endif
    struct iovec iov;	/* iovec for writev(2) */

    /*
     * 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 */
    bzero(&iov, sizeof(struct iovec));
    iov.iov_base = buffer;
    iov.iov_len = size;

    /*
     * 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 */
    }

    /*
     * 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 ***
     */

    /*
     * Determine the system call that will be called and produce
     * the string of the system call and place it in Lio_SysCall.
     * 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) == 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);

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

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

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

        return ret;

    }

    else if ( method & LIO_IO_SYNCV ) {

	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 */

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

    /*
     * 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.
     */
    
    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 */
#ifndef linux
    int listio_cmd;		/* Holds the listio/lio_listio cmd */
    int omethod = method;
#endif
    struct iovec iov; /* iovec for readv(2) */

    /*
     * 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 */
    bzero(&iov, sizeof(struct iovec));
    iov.iov_base = buffer;
    iov.iov_len = size;

    /*
     * 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 */
    }

    /*
     * 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 ***
     */

    /*
     * Determine the system call that will be called and produce
     * the string of the system call and place it in Lio_SysCall.
     * 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) == 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);

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

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

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

        return ret;

    }

    else if ( method & LIO_IO_SYNCV ) {

	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 */

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

    /*
     * 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.
     */
    
    return ret;
}	/* end of lio_read_buffer */


#ifndef linux
/***********************************************************************
 * 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)
 ***********************************************************************/
int
lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
{
    int ret;
    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" :
		 aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
		 "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;

} /* end of lio_check_asyncio */


/***********************************************************************
 *
 * 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)
 ***********************************************************************/
int
lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
{
    int cnt;

    if ( (method & LIO_WAIT_RECALL)
	|| ((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.
         */
        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" :
		 aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
		 "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" :
				 aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
				 "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;
	}
    } else if ( method & LIO_WAIT_ACTIVE ) {
        if ( Debug_level > 2 )
            printf("DEBUG %s/%d: wait method : active\n", __FILE__, __LINE__);

	/* loop while aio_error() returns EINPROGRESS */
	cnt=0;
	while(1){
		ret = aio_error( aiocbp );
		if( (ret == 0) || (ret != EINPROGRESS) ){
			break;
		}
		++cnt;
	}

	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__);
        pause();

    } else if ( method & LIO_WAIT_SIGACTIVE ) {
        if ( Debug_level > 2 )
            printf("DEBUG %s/%d: wait method : sigactive\n", __FILE__, __LINE__);
	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;
	}
	/* loop waiting for signal */
        while ( Received_signal == Rec_signal ){
		sigrelse( aiocbp->aio_sigevent.sigev_signo );
	}

    } 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__ );
        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 */

#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