#ifndef lint
static char sfs_c_bioSid[] = "@(#)sfs_c_bio.c	2.1	97/10/23";
#endif

/*
 *   Copyright (c) 1992-1997,2001 by Standard Performance Evaluation Corporation
 *	All rights reserved.
 *		Standard Performance Evaluation Corporation (SPEC)
 *		6585 Merchant Place, Suite 100
 *		Warrenton, VA 20187
 *
 *	This product contains benchmarks acquired from several sources who
 *	understand and agree with SPEC's goal of creating fair and objective
 *	benchmarks to measure computer performance.
 *
 *	This copyright notice is placed here only to protect SPEC in the
 *	event the source is misused in any manner that is contrary to the
 *	spirit, the goals and the intent of SPEC.
 *
 *	The source code is provided to the user or company under the license
 *	agreement for the SPEC Benchmark Suite for this product.
 */

/*
 * ---------------------- sfs_c_bio.c ---------------------
 *
 *	Routines that attempt to simulate biod behavior
 *
 *	The routines contained here model biod behavior.  Simply call
 *	biod_init() to replace regular calls to op_read() and op_write()
 *	with calls to op_biod_read() and op_biod_write().  The variables
 *	max_out_writes and max_out_reads control the maximum number of
 *	outstanding writes and reads respectively.
 *
 *.Exported Routines
 *	int	biod_init(int, int);
 *	void	biod_turn_on(void);
 *	void	op_biod_write(int, int, int);
 *	void	op_biod_read(int);
 *
 *.Local Routines
 *	uint32_t	biod_clnt_call(CLIENT *, uint32_t,
 *						xdrproc_t, void *);
 *	struct biod_req	*biod_get_reply(CLIENT *, xdrproc_t,
 *						void *, struct timeval *);
 *	int		biod_poll_wait(CLIENT *, uint32_t);
 *
 *.Revision_History
 *	03-May-94	Robinson
 *				History now kept in SCCS
 *	03-Mar-92	0.1.0 Corbin
 *					Added biod behavior
 */

/*
 * -------------------------  Include Files  -------------------------
 */

/*
 * ANSI C headers
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/stat.h> 
 
#include <unistd.h>

#include "sfs_c_def.h"

/*
 * Information associated with outstanding read/write requests
 */
struct biod_req {
    uint32_t		xid;		/* RPC transmission ID	*/
    bool_t		in_use;		/* Indicates if the entry is in use */
    unsigned int	count;		/* Count saved for Dump routines */
    unsigned int	offset;		/* Offset saved for Dump routines */
    struct ladtime	start;		/* Time RPC call was made */
    struct ladtime	stop;		/* Time RPC reply was received */
    struct ladtime	timeout;	/* Time RPC call will time out */
};

/*
 * ----------------------  Static Declarations  ----------------------
 */

static int	max_out_writes;
static int	max_out_reads;
static int	max_biod_reqs = 0;
static struct biod_req *biod_reqp;

/* forward definitions for local functions */
static uint32_t	biod_clnt_call(CLIENT *, uint32_t, xdrproc_t, void *);
static struct biod_req *biod_get_reply(CLIENT *, xdrproc_t,
						void *, struct timeval *);
static int	biod_poll_wait(CLIENT *, uint32_t);

static int op_biod_write(int, int, int);
static int op_biod_read(int);

/*
 * ----------------------  BIOD Support Routines  ----------------------
 */

/*
 * biod_init()
 *
 * This function is called during the initialization phase. It performs
 * the following tasks:
 *	- Allocate memory to hold outstanding biod request information
 *
 * Returns 0 for OK, -1 for failure
 */
int
biod_init(
    int			out_writes,
    int			out_reads)
{
    max_out_writes = MAXIMUM(1, out_writes);
    max_out_reads = MAXIMUM(1, out_reads);
    max_biod_reqs = MAXIMUM(out_writes, out_reads);

    biod_reqp = (struct biod_req *) calloc(max_biod_reqs,
					   sizeof (struct biod_req));
    if (biod_reqp == (struct biod_req *)0) {
	(void) fprintf(stderr, "%s: biod_init calloc failed.\n", sfs_Myname);
	(void) fflush(stderr);
	return (-1);
    }

    return (0);
} /* biod_init */


/*
 *	- Change the operation functions for reads and writes to use the
 *	  biod routines. This step should be done last to allow callers
 *	  to still run with the old op functions if the biod initialization
 *	  fails.
 */
void
biod_turn_on(void)
{
    Ops[WRITE].funct = op_biod_write;
    Ops[READ].funct = op_biod_read;
}

/*
 * biod_term()
 *
 * This function is called during the termination phase to free any resources
 * allocated by the biod_init() routine. It performs the following tasks:
 *	- Frees memory associated with outstanding biod request information
 *	- Frees the biod client handle
 */
void
biod_term(void)
{
    if (max_biod_reqs) {
	free(biod_reqp);
    }
} /* biod_term */

/*
 * Perform and RPC biod style write operation of length 'xfer_size'.
 * If 'append_flag' is true, then write the data to the end of the file.
 */
static int
op_biod_write(
    int			xfer_size,
    int			append_flag,
    int			stab_flag)
{
    sfs_op_type		*op_ptr;	/* per operation info */
    static char		*buf = NULL;	/* the data buffer */
    unsigned int	size;		/* size of data write */
    int			max_cnt;
    attrstat		reply2;		/* the reply */
    writeargs		args2;
    WRITE3res		reply3;		/* the reply */
    WRITE3args		args3;
    struct ladtime	curr_time;
    struct ladtime	tmp_time;
    struct ladtime	call_timeout;
    struct biod_req	*reqp;
    int			ret;		/* ret val == call success */
    int			num_out_reqs;	/* # of outstanding writes */
    int			i;
    int			error;
    int32_t		offset;
    static int		calls = 0;

    calls++;

    if (nfs_version != NFS_VERSION && nfs_version != NFS_V3)
	return (0);

    /*
     * Initialize write buffer to known value
     */  
    if (buf == NULL) {
        buf = init_write_buffer();
    }


    /*
     * For now we treat DATA_SYNC to be the same as FILE_SYNC.
     * If it is not a V3 op then it must always be stable
     */  
    if (stab_flag == DATA_SYNC || nfs_version != NFS_V3)
        stab_flag = FILE_SYNC;

    op_ptr = &Ops[WRITE];
    ret = 0;

    /* set up the arguments */
    (void) memmove((char *) &args2.file, (char *) &Cur_file_ptr->fh2,
			NFS_FHSIZE);
    (void) memmove((char *) &args3.file, (char *) &Cur_file_ptr->fh3,
			sizeof (nfs_fh3));

    args2.beginoffset = 0;	/* unused */

    if (append_flag == 1) {
	args2.offset = Cur_file_ptr->attributes2.size;
	args3.offset = Cur_file_ptr->attributes3.size;
    } else {
	if (fh_size(Cur_file_ptr) > xfer_size) {
	    offset = Bytes_per_block * (sfs_random() %
			    (((fh_size(Cur_file_ptr) - xfer_size)
			    / Bytes_per_block) + 1));
	    args2.offset = offset;
	    args3.offset._p._u = 0;
	    args3.offset._p._l = offset;
	} else {
	    args2.offset = 0;
	    args3.offset._p._u = args3.offset._p._l = 0;
	}
    }

    size = Bytes_per_block;
    args2.totalcount = size;	/* unused */
    args2.data.data_len = size;
    args2.data.data_val = buf;
    args3.data.data_len = size;
    args3.data.data_val = buf;
    args3.count = size;
    args3.stable = stab_flag;

    /* Calculate the number of NFS writes required */
    max_cnt = xfer_size / Bytes_per_block;
    if ((xfer_size % Bytes_per_block) != 0) {
	max_cnt++;
    }

    /* check our stats to see if this would overflow */
    if (!Timed_run) {
	if (op_ptr->target_calls > 0 &&
	   (op_ptr->results.good_calls + max_cnt) > op_ptr->target_calls) {
	    max_cnt = op_ptr->target_calls - op_ptr->results.good_calls;
	}
    }

    if (DEBUG_CHILD_OPS) {
	(void) fprintf(stderr, "write: %d buffers xfer_size %d\n",
			  max_cnt, xfer_size);
	(void) fflush(stderr);
    }

    /* Mark all request slots as not in use */
    for (reqp = biod_reqp, i = 0; i < max_biod_reqs; i++, reqp++) {
	reqp->in_use = FALSE;
    }

    if (Current_test_phase < Warmup_phase) {
	call_timeout.sec = Nfs_timers[Init].tv_sec;
	call_timeout.usec = Nfs_timers[Init].tv_usec;
    } else {
	call_timeout.sec = Nfs_timers[op_ptr->call_class].tv_sec;
	call_timeout.usec = Nfs_timers[op_ptr->call_class].tv_usec;
    }

    /* capture length for possible dump */
    Dump_length = fh_size(Cur_file_ptr);
 
    /* make the call(s) now */
    num_out_reqs = 0;
    while (xfer_size > 0 || num_out_reqs > 0) {
	/*
	 * Send out calls async until either the maximum number of outstanding
	 * requests has been reached or there are no more requests to make.
	 */
	while (num_out_reqs < max_out_writes && xfer_size > 0) {

	    /* find an empty write request slot */
	    for (reqp = biod_reqp, i = 0; i < max_out_writes; i++, reqp++) {
		if (reqp->in_use == FALSE) {
		    break;
		}
	    }

	    if (xfer_size < size) {
		size = xfer_size;
		args2.data.data_len = xfer_size;
		args2.totalcount = xfer_size;		/* unused */
		args3.data.data_len = xfer_size;
		args3.count = xfer_size;
	    }
	    xfer_size -= size;

	    sfs_gettime(&reqp->start);
	    if (nfs_version == NFS_V3) {
		    reqp->xid = biod_clnt_call(NFS_client,
					(uint32_t)NFSPROC3_WRITE,
					xdr_WRITE3args, (char *) &args3);
		    if (reqp->xid != 0) {
			/* capture count and offset for possible dump */
			reqp->count = args3.data.data_len;
			reqp->offset = args3.offset._p._l;
			reqp->timeout = reqp->start;
			ADDTIME(reqp->timeout, call_timeout);
			reqp->in_use = TRUE;
			num_out_reqs++;
	    	    }
	    }
	    if (nfs_version == NFS_VERSION) {
		    reqp->xid = biod_clnt_call(NFS_client,
					(uint32_t)NFSPROC_WRITE,
					xdr_write, (char *) &args2);
		    if (reqp->xid != 0) {
			/* capture count and offset for possible dump */
			reqp->count = args2.data.data_len;
			reqp->offset = args2.offset;
			reqp->timeout = reqp->start;
			ADDTIME(reqp->timeout, call_timeout);
			reqp->in_use = TRUE;
			num_out_reqs++;
	    	    }
	    }
	    if (DEBUG_CHILD_BIOD) {
		(void) fprintf (stderr,
"[%d]:Biod write started xid %x start (%d.%06d) timeo (%d.%06d)\n",
				calls, reqp->xid,
				reqp->start.sec, reqp->start.usec,
				reqp->timeout.sec, reqp->timeout.usec);
	    }

	    args2.offset += size;
	    args3.offset._p._l += size;
	    if (biod_poll_wait(NFS_client, 0) > 0) {
		break;
	    }
	} /* while can make an async call */

	/*
	 * Process replies while there is data on the socket buffer.
	 * Just do polls on the select, no sleeping occurs in this loop.
	 */
	do {
	    error = biod_poll_wait(NFS_client, 0);
	    switch (error) {
		case -1:
		    if (errno == EINTR) {
			error = 1;
			continue;
		    }
		    if (DEBUG_CHILD_BIOD) {
			(void) fprintf(stderr, "%s:[%d]: biod_poll_wait error\n",
					   sfs_Myname, calls);
			(void) fflush(stderr);
		    }
		    break;

		case 0:
		    break;


		default:
		    if (nfs_version == NFS_VERSION)
			    reqp = biod_get_reply(NFS_client, xdr_write,
					  (char *) &reply2,
					  &Nfs_timers[op_ptr->call_class]);
		    if (nfs_version == NFS_V3)
			    reqp = biod_get_reply(NFS_client, xdr_WRITE3res,
					  (char *) &reply3,
					  &Nfs_timers[op_ptr->call_class]);

		    /*
		     * If biod_get_reply returns NULL then we got an RPC
		     * level error, probably a dropped fragment or the
		     * remains of a previous partial request.
		     */
		    if (reqp == (struct biod_req *)NULL) {
			error = 0;
			break;
		    }

		    /*
		     * We have a valid response, check if procedure completed
		     * correctly.
		     */
		    if ((nfs_version == NFS_VERSION &&
			 reply2.status == NFS_OK) ||
			 (nfs_version == NFS_V3 && reply3.status == NFS3_OK)) {
			Cur_file_ptr->state = Exists;
			/*
			 * In updating attributes we may get replies out
			 * of order.  We blindly update the attributes
			 * which may cause old attributes to be stored.
			 * XXX We should check for old attributes.
			 */
		        if (nfs_version == NFS_VERSION)
			    Cur_file_ptr->attributes2 =
					reply2.attrstat_u.attributes;
		        if (nfs_version == NFS_V3)
			    Cur_file_ptr->attributes3 =
					reply3.res_u.ok.file_wcc.after.attr;
			if (DEBUG_CHILD_RPC) {
			    (void) fprintf(stderr,
					"%s: WRITE %s %d bytes offset %d \n",
					sfs_Myname, Cur_filename,
					reqp->count, reqp->offset);
			    (void) fflush(stderr);
			}

			/* capture count and offset for possible dump */
			Dump_count = reqp->count;
			Dump_offset = reqp->offset;
			sfs_elapsedtime(op_ptr, &reqp->start, &reqp->stop);
			op_ptr->results.good_calls++;
			Ops[TOTAL].results.good_calls++;
			ret++;
			reqp->in_use = FALSE;
			num_out_reqs--;
		        if (DEBUG_CHILD_BIOD) {
			    (void) fprintf (stderr,
"[%d]:Biod write succeded xid %x start (%d.%06d) timeo (%d.%06d) stop (%d.%06d)\n",
				calls, reqp->xid,
				reqp->start.sec, reqp->start.usec,
				reqp->timeout.sec, reqp->timeout.usec,
				reqp->stop.sec, reqp->stop.usec);
			}
		    } else {
			op_ptr->results.bad_calls++;
			Ops[TOTAL].results.bad_calls++;
			reqp->in_use = FALSE;
			num_out_reqs--;
		        if (DEBUG_CHILD_BIOD) {
			    (void) fprintf (stderr,
"[%d]:Biod write failed xid %x start (%d.%06d) timeo (%d.%06d)\n",
				calls, reqp->xid,
				reqp->start.sec, reqp->start.usec,
				reqp->timeout.sec, reqp->timeout.usec);

			    (void) fprintf(stderr,
				    "[%d]:BIOD WRITE FAILED: xid %x",
				    calls, reqp->xid);

			    if (nfs_version == NFS_VERSION)
			        (void) fprintf(stderr, "  status %d",
								reply2.status);
			    if (nfs_version == NFS_V3)
			        (void) fprintf(stderr, "  status %d",
								reply3.status);
			    (void) fprintf(stderr, "\n");
			}
		    }
		    break;
	    }
	} while (error > 0 && num_out_reqs > 0);

	/* Scan for replies that have timed out */
	if (num_out_reqs > 0) {
	    sfs_gettime(&curr_time);
	    for (reqp = biod_reqp, i = 0; i < max_out_writes; i++, reqp++) {
		if (reqp->in_use == FALSE) {
		    continue;
		}
		if (reqp->timeout.sec < curr_time.sec ||
		    (reqp->timeout.sec == curr_time.sec &&
		    reqp->timeout.usec < curr_time.usec)) {

		    op_ptr->results.bad_calls++;
		    Ops[TOTAL].results.bad_calls++;
		    reqp->in_use = FALSE;
		    num_out_reqs--;
		    if (DEBUG_CHILD_BIOD) {
			(void) fprintf (stderr,
"[%d]:Biod write timed out %x start (%d.%06d) timeo (%d.%06d) now (%d.%06d)\n",
				calls, reqp->xid,
				reqp->start.sec, reqp->start.usec,
				reqp->timeout.sec, reqp->timeout.usec,
				curr_time.sec, curr_time.usec);
			if (biod_poll_wait(NFS_client, 0) > 0) {
			   (void) fprintf(stderr,
				"[%d]:BIOD WRITE TIMEOUT - data on input queue!\n", calls);
			}
		    }
		}
	    }
	}

	/*
	 * We go to sleep waiting for a reply if all the requests have
	 * been sent and there are outstanding requests, or we cannot
	 * send any more requests.
	 */
	if ((xfer_size <= 0 && num_out_reqs > 0) ||
	    num_out_reqs == max_out_writes) {
	    /*
	     * Find the next outstanding request that will timeout
	     * and take a time differential to use for the poll timeout.
	     * If the differential is less than zero, then we go to the
	     * top of the loop. Note that we are not picky on errors
	     * returned by select, after the sleep we return to the top
	     * of the loop so extensive error/status checking is not
	     * needed.
	     */
	    tmp_time.sec = 0;
	    tmp_time.usec = 0;
	    for (reqp = biod_reqp, i = 0; i < max_out_writes; i++, reqp++) {
		if (reqp->in_use == FALSE) {
		    continue;
		}
		if (tmp_time.sec == 0 ||
		    (reqp->timeout.sec < tmp_time.sec ||
		     (reqp->timeout.sec == tmp_time.sec &&
		      reqp->timeout.usec < tmp_time.usec))) {
		    
		     tmp_time = reqp->timeout;
		}
	    }
	    if (tmp_time.sec == 0 && tmp_time.usec == 0)
		continue;
	    sfs_gettime(&curr_time);
	    SUBTIME(tmp_time, curr_time);
	    (void) biod_poll_wait(NFS_client,
					tmp_time.sec * 1000000 + tmp_time.usec);
	}
    } /* while not done */

 
    /*
     * If we have not gotten an error and we were asked for an async write
     * send a commit operation.
     */  
    if (ret && stab_flag != FILE_SYNC)
	ret += (*Ops[COMMIT].funct)();

    return (ret);

} /* op_biod_write */


/*
 * perform an RPC read operation of length 'xfer_size'
 */
static int
op_biod_read(
    int 			xfer_size)
{
    sfs_op_type			*op_ptr;	/* per operation info */
    int				max_cnt;	/* packet ctrs */
    char			buf[DEFAULT_MAX_BUFSIZE];/* data buffer */
    readargs			args2;
    readres			reply2;		/* the reply */
    READ3args			args3;
    READ3res			reply3;		/* the reply */
    int				size;
    struct ladtime		curr_time;
    struct ladtime		call_timeout;
    struct ladtime		tmp_time;
    struct biod_req		*reqp;
    int				ret;		/* ret val == call success */
    int				num_out_reqs;	/* # of outstanding writes */
    int				i;
    int				error;
    int32_t			offset;
    static int		calls = 0;

    calls++;

    if (nfs_version != NFS_VERSION && nfs_version != NFS_V3)
	return (0);

    op_ptr = &Ops[READ];
    ret = 0;

    /* set up the arguments */
    (void) memmove((char *) &args2.file, (char *) &Cur_file_ptr->fh2,
			NFS_FHSIZE);
    (void) memmove((char *) &args3.file, (char *) &Cur_file_ptr->fh3,
			sizeof (nfs_fh3));

    /*
     * Don't allow a read of less than one block size
     */
    if (xfer_size < Bytes_per_block)
        xfer_size = Bytes_per_block;
 

    /* Calculate the number of NFS reads required */
    max_cnt = xfer_size / Bytes_per_block;
    if ((xfer_size % Bytes_per_block) != 0) {
	    max_cnt++;
    }

    /* check our stats to see if this would overflow */
    if (!Timed_run) {
	if (op_ptr->target_calls > 0 &&
	    (op_ptr->results.good_calls + max_cnt) > op_ptr->target_calls) {
	    max_cnt = op_ptr->target_calls - op_ptr->results.good_calls;
	}
    }

    args2.offset = 0;
    args3.offset._p._l = args3.offset._p._u = 0;

    /*
     * randomly choose an offset that is a multiple of the block size
     * and constrained by making the transfer fit within the file
     */
    if (fh_size(Cur_file_ptr) > xfer_size) {
	offset = Bytes_per_block * (sfs_random() %
			    (((fh_size(Cur_file_ptr) - xfer_size)
			    / Bytes_per_block) + 1));
	args2.offset = offset;
	args3.offset._p._u = 0;
	args3.offset._p._l = offset;
    }

    size = Bytes_per_block;
    args2.count = size;
    args3.count = size;
    args2.totalcount = size;	/* unused */

    /* Have lower layers fill in the data directly.  */
    reply2.readres_u.reply.data.data_val = buf;
    reply3.res_u.ok.data.data_val = buf;

    if (DEBUG_CHILD_OPS) {
	(void) fprintf(stderr, "read: %d buffers xfer_size %d\n",
			  max_cnt, xfer_size);
	(void) fflush(stderr);
    }

    /* Mark all request slots as not in use */
    for (reqp = biod_reqp, i = 0; i < max_biod_reqs; i++, reqp++) {
	reqp->in_use = FALSE;
    }

    if (Current_test_phase < Warmup_phase) {
	call_timeout.sec = Nfs_timers[Init].tv_sec;
	call_timeout.usec = Nfs_timers[Init].tv_usec;
    } else {
	call_timeout.sec = Nfs_timers[op_ptr->call_class].tv_sec;
	call_timeout.usec = Nfs_timers[op_ptr->call_class].tv_usec;
    }

    /* capture length for possible dump */
    Dump_length = fh_size(Cur_file_ptr);

    /* make the call(s) now */
    num_out_reqs = 0;
    while (xfer_size > 0 || num_out_reqs > 0) {
	/*
	 * Send out calls async until either the maximum number of outstanding
	 * requests has been reached or there are no more requests to make.
	 */
	while (num_out_reqs < max_out_reads && xfer_size > 0) {

	    /* find an empty read request slot */
	    for (reqp = biod_reqp, i = 0; i < max_out_reads; i++, reqp++) {
		if (reqp->in_use == FALSE) {
		    break;
		}
	    }

	    if (xfer_size < size) {
		size = xfer_size;
		args2.count = xfer_size;
		args3.count = xfer_size;
		args2.totalcount = xfer_size;		/* unused */
	    }
	    xfer_size -= size;

	    sfs_gettime(&reqp->start);
	    if (nfs_version == NFS_VERSION) {
		reqp->xid = biod_clnt_call(NFS_client,
					(uint32_t)NFSPROC_READ,
					xdr_read, (char *) &args2);
		if (reqp->xid != 0) {
		    /* capture count and offset for possible dump */
		    reqp->count = args2.count;
		    reqp->offset = args2.offset;
		    reqp->timeout = reqp->start;
		    ADDTIME(reqp->timeout, call_timeout);
		    reqp->in_use = TRUE;
		    num_out_reqs++;
		}
	    } else if (nfs_version == NFS_V3) {
		reqp->xid = biod_clnt_call(NFS_client,
					(uint32_t)NFSPROC3_READ,
					xdr_READ3args, (char *) &args3);
		if (reqp->xid != 0) {
		    /* capture count and offset for possible dump */
		    reqp->count = args3.count;
		    reqp->offset = args3.offset._p._l;
		    reqp->timeout = reqp->start;
		    ADDTIME(reqp->timeout, call_timeout);
		    reqp->in_use = TRUE;
		    num_out_reqs++;
		}
	    }

	    args2.offset += size;
	    args3.offset._p._l += size;
	    if (biod_poll_wait(NFS_client, 0) > 0) {
		break;
	    }
	} /* while can make an async call */

	/*
	 * Process replies while there is data on the socket buffer.
	 * Just do polls on the select, no sleeping occurs in this loop.
	 */
	do {
	    error = biod_poll_wait(NFS_client, 0);
	    switch (error) {
		case -1:
		    if (errno == EINTR) {
			error = 1;
			continue;
		    }
		    if (DEBUG_CHILD_BIOD) {
			(void) fprintf(stderr,
					"%s:[%d]: biod_poll_wait error\n",
					sfs_Myname, calls);
			(void) fflush(stderr);
		    }
		    break;

		case 0:
		    break;


		default:
		    if (nfs_version == NFS_VERSION)
		        reqp = biod_get_reply(NFS_client, xdr_read,
					  (char *) &reply2,
					  &Nfs_timers[op_ptr->call_class]);
		    if (nfs_version == NFS_V3)
		        reqp = biod_get_reply(NFS_client, xdr_READ3res,
					  (char *) &reply3,
					  &Nfs_timers[op_ptr->call_class]);

		    /*
		     * If biod_get_reply returns NULL then we got an RPC
		     * level error, probably a dropped fragment or the
		     * remains of a previous partial request.
		     */
		    if (reqp == (struct biod_req *)NULL) {
			error = 0;
			break;
		    }

		    /*
		     * We have a valid response, check if procedure completed
		     * correctly.
		     */
		    if ((nfs_version == NFS_VERSION &&
						reply2.status == NFS_OK) ||
			 (nfs_version == NFS_V3 &&
						reply3.status == NFS3_OK)) {
			Cur_file_ptr->state = Exists;
			if (DEBUG_CHILD_RPC) {
			    (void) fprintf(stderr, "%s: READ %s %d bytes offset %d\n",
			    	   sfs_Myname, Cur_filename, reqp->count, reqp->offset);
			    (void) fflush(stderr);
			}
			/*
			 * In updating attributes we may get replies out
			 * of order.  We blindly update the attributes
			 * which may cause old attributes to be stored.
			 * XXX We should check for old attributes.
			 */
			if (nfs_version == NFS_VERSION) {
			    Cur_file_ptr->attributes2 =
					reply2.readres_u.reply.attributes;
			    /* capture count and offset for possible dump */
			    Dump_count = reply2.readres_u.reply.data.data_len;
			}
			if (nfs_version == NFS_V3) {
			    Cur_file_ptr->attributes3 =
					reply3.res_u.ok.file_attributes.attr;
			    /* capture count and offset for possible dump */
			    Dump_count = reply3.res_u.ok.data.data_len;
			}

			Dump_offset = reqp->offset;
			sfs_elapsedtime(op_ptr, &reqp->start, &reqp->stop);
			op_ptr->results.good_calls++;
			Ops[TOTAL].results.good_calls++;
			ret++;
			reqp->in_use = FALSE;
			num_out_reqs--;
		    } else {
			op_ptr->results.bad_calls++;
			Ops[TOTAL].results.bad_calls++;
			reqp->in_use = FALSE;
			num_out_reqs--;

			if (DEBUG_CHILD_BIOD) {
			    (void) fprintf(stderr,
				    "[%d]:BIOD READ FAILED: xid %x",
				    calls, reqp->xid);

			    if (nfs_version == NFS_VERSION)
			        (void) fprintf(stderr, "  status %d",
								reply2.status);
			    if (nfs_version == NFS_V3)
			        (void) fprintf(stderr, "  status %d",
								reply3.status);
			    (void) fprintf(stderr, "\n");
			}
		    }
		    break;
	    } /* switch */
	} while (error > 0 && num_out_reqs > 0);

	/* Scan for replies that have timed out */
	if (num_out_reqs > 0) {
	    sfs_gettime(&curr_time);
	    for (reqp = biod_reqp, i = 0; i < max_out_reads; i++, reqp++) {
		if (reqp->in_use == FALSE) {
		    continue;
		}
		if (reqp->timeout.sec < curr_time.sec ||
		    (reqp->timeout.sec == curr_time.sec &&
		     reqp->timeout.usec < curr_time.usec)) {

		    op_ptr->results.bad_calls++;
		    Ops[TOTAL].results.bad_calls++;
		    reqp->in_use = FALSE;
		    num_out_reqs--;
		    if (DEBUG_CHILD_BIOD) {
			(void) fprintf (stderr,
"[%d]:Biod read timed out %x (%d.%06d) now (%d.%06d)\n",
				calls, reqp->xid,
				reqp->timeout.sec, reqp->timeout.usec,
				curr_time.sec, curr_time.usec);
			if (biod_poll_wait(NFS_client, 0) > 0) {
			   (void) fprintf(stderr,
				"[%d]:BIOD READ TIMEOUT - data on input queue!\n", calls);
			}
		    }
		}
	    }
	}

	/*
	 * We go to sleep waiting for a reply if all the requests have
	 * been sent and there are outstanding requests, or we cannot
	 * send any more requests.
	 */
	if ((xfer_size <= 0 && num_out_reqs > 0) ||
	    num_out_reqs == max_out_reads) {
	    /*
	     * Find the next outstanding request that will timeout
	     * and take a time differential to use for the poll timeout.
	     * If the differential is less than zero, then we go to the
	     * top of the loop. Note that we are not picky on errors
	     * returned by select, after the sleep we return to the top
	     * of the loop so extensive error/status checking is not
	     * needed.
	     */
	    tmp_time.sec = 0;
	    tmp_time.usec = 0;
	    for (reqp = biod_reqp, i = 0; i < max_out_reads; i++, reqp++) {
		if (reqp->in_use == FALSE) {
		    continue;
		}
		if (tmp_time.sec == 0 ||
		    (reqp->timeout.sec < tmp_time.sec ||
		     (reqp->timeout.sec == tmp_time.sec &&
		      reqp->timeout.usec < tmp_time.usec))) {
		    
		     tmp_time = reqp->timeout;
		}
	    }
	    if (tmp_time.sec == 0 && tmp_time.usec == 0)
		continue;
	    sfs_gettime(&curr_time);
	    SUBTIME(tmp_time, curr_time);
	    (void) biod_poll_wait(NFS_client,
					tmp_time.sec * 1000000 + tmp_time.usec);
	}
    } /* while not done */

    return(ret);

} /* op_biod_read */

/*
 * ----------------------  Async RPC Support Routines  ----------------------
 */

/*
 * biod_clnt_call()
 *
 * Returns XID indicating success, 0 indicating failure.
 */
static uint32_t
biod_clnt_call(
    CLIENT		*clnt_handlep,
    uint32_t		proc,
    xdrproc_t		xargs,
    void		*argsp)
{
    struct timeval timeout;
    uint32_t xid;

    /*
     * Set timeouts to be zero to force message passing semantics.
     */
    timeout.tv_sec = 0;
    timeout.tv_usec = 0;

    if ((clnt_call(clnt_handlep, proc, xargs, argsp, NULL,
					&xid, timeout)) != RPC_TIMEDOUT) {
	clnt_perror(clnt_handlep, "biod_clnt_call failed");
	return (0);
    }

    return (xid);
} /* biod_clnt_call */


/*
 * biod_get_reply()
 *
 * Returns pointer to the biod_req struct entry that a reply was received
 * for.  Returns NULL if an error was detected.
 * NOTES:
 * 1) This routine should only be called when it is known that there is
 *    data waiting on the socket.
 */
static struct biod_req *
biod_get_reply(
    CLIENT		*clnt_handlep,
    xdrproc_t		xresults,
    void		*resultsp,
    struct timeval	*tv)
{
    uint32_t		xid;
    int			i;
    int			cnt = 0;
    bool_t		res;
    uint32_t		xids[MAX_BIODS];

    /*
     * Load list of valid outstanding xids
     */
    for (i = 0; i < max_biod_reqs; i++) {
        if (biod_reqp[i].in_use == TRUE)
	    xids[cnt++] = biod_reqp[i].xid;
    }

    if (cnt == 0)
	return (NULL);

    if ((res = clnt_getreply(clnt_handlep, xresults,
			resultsp, cnt, xids, &xid, tv)) != RPC_SUCCESS) {
	if (DEBUG_CHILD_BIOD) {
		if (res == RPC_CANTDECODERES) {
			(void) fprintf(stderr, "No xid matched, found %x\n",
				xid);
		}
	}
	return (NULL);
    }

    /*
     * Scan to find XID matched in the outstanding request queue.
     */
    for (i = 0; i < max_biod_reqs; i++) {
        if (biod_reqp[i].in_use == TRUE && biod_reqp[i].xid == xid) {
	    sfs_gettime(&(biod_reqp[i].stop));
	    return (&biod_reqp[i]);
        }
    }

    return ((struct biod_req *)0);
} /* biod_get_reply */


/*
 * biod_poll_wait()
 *
 * Returns -1 on error, 0 for no data available, > 0 to indicate data available
 */
static int
biod_poll_wait(
    CLIENT		*clnt_handlep,
    uint32_t		usecs)
{
    return (clnt_poll(clnt_handlep, usecs));
} /* biod_poll_wait */