Update copyright annotations and license boilerplates to correspond with SGI Legals...
[xfstests-dev.git] / lib / tlibio.c
1 /*
2  * Copyright (c) 2000 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 /*
19  *
20  * Lib i/o
21  *
22  * This file contains several functions to doing reads and writes.
23  * It was written so that a single function could be called in a test
24  * program and only a io type field value would have to change to
25  * do different types of io.  There is even a couple of functions that
26  * will allow you to parse a string to determine the iotype.
27  *
28  * This file contains functions for writing/reading to/from open files
29  * Prototypes:
30  *
31  * Functions declared in this module - see individual function code for
32  * usage comments:
33  *
34  *  int  stride_bounds(int offset, int stride, int nstrides,
35  *                    int bytes_per_stride, int *min, int *max);
36
37  *  int  lio_write_buffer(int fd, int method, char *buffer, int size,
38  *                                              char **errmsg, long wrd);
39  *  int  lio_read_buffer(int fd, int method, char *buffer, int size,
40  *                                              char **errmsg, long wrd);
41  *
42  *  #ifdef CRAY
43  *  int  lio_wait4asyncio(int method, int fd, struct iosw **statptr)
44  *  int  lio_check_asyncio(char *io_type, int size, struct iosw *status)
45  *  #endif
46  *  #ifdef sgi
47  *  int  lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
48  *  int  lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
49  *  #endif
50  *
51  *  int  lio_parse_io_arg1(char *string)
52  *  void lio_help1(char *prefix);
53  *
54  *  int  lio_parse_io_arg2(char *string, char **badtoken)
55  *  void lio_help2(char *prefix);
56  *
57  *  int  lio_set_debug(int level);
58  *
59  *  char Lio_SysCall[];
60  *  struct lio_info_type Lio_info1[];
61  *  struct lio_info_type Lio_info2[];
62  *
63  *  Author : Richard Logan
64  *
65  */
66
67 #include <stdio.h>
68 #include <ctype.h>
69 #include <fcntl.h>
70 #include <unistd.h>
71 #include <sys/types.h>
72 #include <sys/stat.h>
73 #include <sys/time.h>          
74 #include <sys/param.h>
75 #include <errno.h>
76 #include <sys/types.h>
77 #include <sys/file.h>
78 #include <signal.h>
79 #ifdef CRAY
80 #include <sys/secparm.h>
81 #include <sys/iosw.h>
82 #include <sys/listio.h>
83 #else
84 /* for linux or sgi */
85 #include <sys/uio.h> /* readv(2)/writev(2) */
86 #include <string.h>
87 #include <strings.h>
88 #endif
89 #ifdef sgi
90 #include <aio.h>
91 #endif
92 #include <stdlib.h> /* atoi, abs */
93
94 #include "tlibio.h"             /* defines LIO* marcos */
95
96 #ifndef PATH_MAX
97 #define PATH_MAX        MAXPATHLEN
98 #endif
99
100 #if 0 /* disabled until it's needed -- roehrich 6/11/97 */
101 #define BUG1_workaround 1 /* Work around a condition where aio_return gives
102                            * a value of zero but there is no errno followup
103                            * and the read/write operation actually did its
104                            * job.   spr/pv 705244
105                            */
106 #endif
107
108
109 #ifndef linux
110 static void lio_async_signal_handler();
111 #endif
112 #ifdef sgi
113 static void lio_async_callback_handler();
114 #endif
115
116 /*
117  * Define the structure as used in lio_parse_arg1 and lio_help1
118  */
119 struct lio_info_type  Lio_info1[] = {
120     { "s", LIO_IO_SYNC, "sync i/o" },
121     { "p", LIO_IO_ASYNC|LIO_WAIT_SIGACTIVE, "async i/o using a loop to wait for a signal" },
122     { "b", LIO_IO_ASYNC|LIO_WAIT_SIGPAUSE, "async i/o using pause" },
123     { "a", LIO_IO_ASYNC|LIO_WAIT_RECALL, "async i/o using recall/aio_suspend" },
124 #ifdef sgi
125     { "r", 
126         LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random sync i/o types and wait methods" },
127     { "R", 
128         LIO_RANDOM|LIO_IO_ATYPES|LIO_WAIT_ATYPES, "random i/o types and wait methods" },
129 #else
130     { "r", 
131         LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
132     { "R", 
133         LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
134 #endif
135     { "l", LIO_IO_SLISTIO|LIO_WAIT_RECALL, "single stride sync listio" },
136     { "L", LIO_IO_ALISTIO|LIO_WAIT_RECALL, "single stride async listio using recall" },
137     { "X", LIO_IO_ALISTIO|LIO_WAIT_SIGPAUSE, "single stride async listio using pause" },
138     { "v", LIO_IO_SYNCV, "single buffer sync readv/writev" },
139     { "P", LIO_IO_SYNCP, "sync pread/pwrite" },
140 };
141
142 /*
143  * Define the structure used by lio_parse_arg2 and lio_help2
144  */
145 struct lio_info_type  Lio_info2[] = {
146     { "sync",      LIO_IO_SYNC,         "sync i/o (read/write)"},
147     { "async",     LIO_IO_ASYNC,        "async i/o (reada/writea/aio_read/aio_write)" },
148     { "slistio",   LIO_IO_SLISTIO,      "single stride sync listio" },
149     { "alistio",   LIO_IO_ALISTIO,      "single stride async listio" },
150     { "syncv",     LIO_IO_SYNCV,        "single buffer sync readv/writev"},
151     { "syncp",     LIO_IO_SYNCP,        "pread/pwrite"},
152     { "active",    LIO_WAIT_ACTIVE,     "spin on status/control values" },
153     { "recall",    LIO_WAIT_RECALL,     "use recall(2)/aio_suspend(3) to wait for i/o to complete" },
154     { "sigactive", LIO_WAIT_SIGACTIVE,  "spin waiting for signal" },
155     { "sigpause",  LIO_WAIT_SIGPAUSE,   "call pause(2) to wait for signal" },
156 /* nowait is a touchy thing, it's an accident that this implementation worked at all.  6/27/97 roehrich */
157 /*    { "nowait",    LIO_WAIT_NONE,     "do not wait for async io to complete" },*/
158     { "random",    LIO_RANDOM,          "set random bit" },
159     { "randomall", 
160         LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, 
161         "all random i/o types and wait methods (except nowait)" },
162 };
163
164 char Lio_SysCall[PATH_MAX];     /* string containing last i/o system call */
165
166 static volatile int Received_signal = 0;        /* number of signals received */
167 static volatile int Rec_signal;
168 #ifdef sgi
169 static volatile int Received_callback = 0;      /* number of callbacks received */
170 static volatile int Rec_callback;
171 #endif
172 static char Errormsg[500];
173 static int Debug_level = 0;
174
175
176
177 /***********************************************************************
178  * stride_bounds()
179  *
180  * Determine the bounds of a strided request, normalized to offset.  Returns
181  * the number of bytes needed to satisfy the request, and optionally sets
182  * *min and *max to the mininum and maximum bytes referenced, normalized 
183  * around offset.
184  *
185  * Returns -1 on error - the only possible error conditions are illegal values
186  * for nstrides and/or bytes_per_stride - both parameters must be >= 0.
187  *
188  * (maule, 11/16/95)
189  ***********************************************************************/
190
191 int
192 stride_bounds(offset, stride, nstrides, bytes_per_stride, min, max)
193 int     offset;
194 int     stride;
195 int     nstrides;
196 int     bytes_per_stride;
197 int     *min;
198 int     *max;
199 {
200         int     nbytes, min_byte, max_byte;
201
202         /*
203          * sanity checks ...
204          */
205
206         if (nstrides < 0 || bytes_per_stride < 0) {
207                 return -1;
208         }
209
210         if (stride == 0) {
211                 stride = bytes_per_stride;
212         }
213
214         /*
215          * Determine the # of bytes needed to satisfy the request.  This
216          * value, along with the offset argument, determines the min and max
217          * bytes referenced.
218          */
219
220
221         nbytes = abs(stride) * (nstrides-1) + bytes_per_stride;
222
223         if (stride < 0) {
224                 max_byte = offset + bytes_per_stride - 1;
225                 min_byte = max_byte - nbytes + 1;
226         } else {
227                 min_byte = offset;
228                 max_byte = min_byte + nbytes - 1;
229         }
230         
231         if (min != NULL) {
232                 *min = min_byte;
233         }
234         
235         if (max != NULL) {
236                 *max = max_byte;
237         }
238
239         return nbytes;
240 }
241
242 /***********************************************************************
243  * This function will allow someone to set the debug level.
244  ***********************************************************************/
245 int
246 lio_set_debug(level)
247 {
248     int old;
249
250     old = Debug_level;
251     Debug_level = level;
252     return old;
253 }
254
255 /***********************************************************************
256  * This function will parse a string and return desired io-method.
257  * Only the first character of the string is used.
258  *
259  * This function does not provide for meaningful option arguments,
260  * but it supports current growfiles/btlk interface.
261  *
262  *  (rrl 04/96)
263  ***********************************************************************/
264 int
265 lio_parse_io_arg1(char *string)
266 {
267     int ind;
268     int found=0;
269     int mask=0;
270
271     /*
272      * Determine if token is a valid string.
273      */
274     for(ind=0; ind<sizeof(Lio_info1)/sizeof(struct lio_info_type); ind++) {
275         if ( strcmp(string, Lio_info1[ind].token) == 0 ) {
276             mask |= Lio_info1[ind].bits;
277             found = 1;
278             break;
279         }
280     }
281
282     if ( found == 0 ) {
283         return -1;
284     }
285
286     return mask;
287
288 }
289
290 /***********************************************************************
291  * This function will print a help message describing the characters
292  * that can be parsed by lio_parse_io_arg1().
293  * They will be printed one per line.
294  *  (rrl 04/96)
295  ***********************************************************************/
296 void
297 lio_help1(char *prefix)
298 {
299     int ind;
300
301     for(ind=0; ind<sizeof(Lio_info1)/sizeof(struct lio_info_type); ind++) {
302         printf("%s %s : %s\n", prefix,
303             Lio_info1[ind].token, Lio_info1[ind].desc);
304     }
305
306     return;
307 }
308
309 /***********************************************************************
310  * This function will parse a string and return the desired io-method.
311  * This function will take a comma separated list of io type and wait
312  * method tokens as defined in Lio_info2[].  If a token does not match
313  * any of the tokens in Lio_info2[], it will be coverted to a number.
314  * If it was a number, those bits are also set.
315  * 
316  *  (rrl 04/96)
317  ***********************************************************************/
318 int
319 lio_parse_io_arg2(char *string, char **badtoken)
320 {
321    char *token = string;
322    char *cc = token;
323    char savecc;
324    int found;
325    int mask=0;
326
327    int tmp;
328    int ind;
329    char chr;
330
331    if ( token == NULL )
332         return -1;
333
334    for (;;) {
335         for (; ((*cc != ',') && (*cc != '\0')); cc++);
336         savecc = *cc;
337         *cc = '\0';
338
339         found = 0; 
340
341         /*
342          * Determine if token is a valid string or number and if
343          * so, add the bits to the mask.
344           */
345         for(ind=0; ind<sizeof(Lio_info2)/sizeof(struct lio_info_type); ind++) {
346             if ( strcmp(token, Lio_info2[ind].token) == 0 ) {
347                 mask |= Lio_info2[ind].bits;
348                 found = 1;
349                 break;
350             }
351         }
352
353         /*
354          * If token does not match one of the defined tokens, determine
355          * if it is a number, if so, add the bits.
356          */
357         if ( !found ) {
358             if (sscanf(token, "%i%c", &tmp, &chr) == 1 ) {
359                 mask |= tmp;
360                 found=1;
361             }
362         }
363
364         *cc = savecc;
365
366         if (!found) {  /* token is not valid */
367             if ( badtoken != NULL)
368                 *badtoken = token;
369             return(-1);
370         }
371
372         if (savecc == '\0')
373             break;
374
375         token = ++cc;
376     }
377
378     return mask;
379 }
380
381 /***********************************************************************
382  * This function will print a help message describing the tokens
383  * that can be parsed by lio_parse_io_arg2().
384  * It will print them one per line.
385  *
386  * (rrl 04/96)
387  ***********************************************************************/
388 void
389 lio_help2(char *prefix)
390 {
391     int ind;
392
393     for(ind=0; ind<sizeof(Lio_info2)/sizeof(struct lio_info_type); ind++) {
394         printf("%s %s : %s\n", prefix,
395             Lio_info2[ind].token, Lio_info2[ind].desc);
396     }
397     return;
398 }
399
400 #ifndef linux
401 /***********************************************************************
402  * This is an internal signal handler.
403  * If the handler is called, it will increment the Received_signal
404  * global variable.
405  ***********************************************************************/
406 static void
407 lio_async_signal_handler(int sig)
408 {
409         if ( Debug_level )
410             printf("DEBUG %s/%d: received signal %d, a signal caught %d times\n",
411                 __FILE__, __LINE__, sig, Received_signal+1);
412
413         Received_signal++;
414
415         return;
416 }
417 #endif
418
419 #ifdef sgi
420 /***********************************************************************
421  * This is an internal callback handler.
422  * If the handler is called, it will increment the Received_callback
423  * global variable.
424  ***********************************************************************/
425 static void
426 lio_async_callback_handler(sigval_t sigval)
427 {
428         if ( Debug_level )
429             printf("DEBUG %s/%d: received callback, nbytes=%d, a callback called %d times\n",
430                 __FILE__, __LINE__, sigval.sival_int, Received_callback+1);
431
432         Received_callback++;
433
434         return;
435 }
436 #endif /* sgi */
437
438 /***********************************************************************
439  * lio_random_methods
440  * This function will randomly choose an io type and wait method
441  * from set of io types and wait methods.  Since this information
442  * is stored in a bitmask, it randomly chooses an io type from
443  * the io type bits specified and does the same for wait methods.
444  *
445  * Return Value
446  * This function will return a value with all non choosen io type
447  * and wait method bits cleared.  The LIO_RANDOM bit is also 
448  * cleared.  All other bits are left unchanged.
449  *
450  * (rrl 04/96)
451  ***********************************************************************/
452 int
453 lio_random_methods(long curr_mask)
454 {
455     int mask=0;
456     long random_bit();
457
458     /* remove random select, io type, and wait method bits from curr_mask */
459     mask = curr_mask & (~(LIO_IO_TYPES | LIO_WAIT_TYPES | LIO_RANDOM));
460
461     /* randomly select io type from specified io types */
462     mask = mask | random_bit(curr_mask & LIO_IO_TYPES);
463
464     /* randomly select wait methods  from specified wait methods */
465     mask = mask | random_bit(curr_mask & LIO_WAIT_TYPES);
466
467     return mask;
468 }
469
470 /***********************************************************************
471  * Generic write function 
472  * This function can be used to do a write using write(2), writea(2),
473  * aio_write(3), writev(2), pwrite(2),
474  * or single stride listio(2)/lio_listio(3).
475  * By setting the desired bits in the method
476  * bitmask, the caller can control the type of write and the wait method
477  * that will be used.  If no io type bits are set, write will be used.
478  *
479  * If async io was attempted and no wait method bits are set then the
480  * wait method is: recall(2) for writea(2) and listio(2); aio_suspend(3) for
481  * aio_write(3) and lio_listio(3).
482  *
483  * If multiple wait methods are specified, 
484  * only one wait method will be used. The order is predetermined.
485  *
486  * If the call specifies a signal and one of the two signal wait methods,
487  * a signal handler for the signal is set.  This will reset an already
488  * set handler for this signal. 
489  *
490  * If the LIO_RANDOM method bit is set, this function will randomly
491  * choose a io type and wait method from bits in the method argument.
492  *
493  * If an error is encountered, an error message will be generated
494  * in a internal static buffer.  If errmsg is not NULL, it will
495  * be updated to point to the static buffer, allowing the caller
496  * to print the error message.
497  *
498  * Return Value
499  *   If a system call fails, -errno is returned.
500  *   If LIO_WAIT_NONE bit is set, the return value is the return value
501  *   of the system call.
502  *   If the io did not fail, the amount of data written is returned.
503  *      If the size the system call say was written is different
504  *      then what was asked to be written, errmsg is updated for
505  *      this error condition.  The return value is still the amount
506  *      the system call says was written.  
507  *
508  * (rrl 04/96)
509  ***********************************************************************/
510 int
511 lio_write_buffer(fd, method, buffer, size, sig, errmsg, wrd)
512 int fd;         /* open file descriptor */
513 int method;     /* contains io type and wait method bitmask */
514 char *buffer;   /* pointer to buffer */
515 int size;       /* the size of the io */
516 int sig;        /* signal to use if async io */
517 char **errmsg;  /* char pointer that will be updated to point to err message */
518 long wrd;       /* to allow future features, use zero for now */
519 {
520     int ret = 0;        /* syscall return or used to get random method */
521     char *io_type;              /* Holds string of type of io */
522 #ifndef linux
523     int omethod = method;
524     int listio_cmd;             /* Holds the listio/lio_listio cmd */
525 #endif
526 #ifdef  CRAY
527     struct listreq request;     /* Used when a listio is wanted */
528     struct iosw status, *statptr[1];  
529 #else
530     /* for linux or sgi */
531     struct iovec iov;   /* iovec for writev(2) */
532 #endif
533 #ifdef sgi
534     aiocb_t aiocbp;     /* POSIX aio control block */
535     aiocb_t *aiolist[1]; /* list of aio control blocks for lio_listio */
536     off64_t poffset;    /* pwrite(2) offset */
537 #endif
538
539     /*
540      * If LIO_RANDOM bit specified, get new method randomly.
541      */
542     if ( method & LIO_RANDOM ) {
543         if( Debug_level > 3 )
544                 printf("DEBUG %s/%d: method mask to choose from: %#o\n", __FILE__, __LINE__, method );
545         method = lio_random_methods(method);
546         if ( Debug_level > 2 )
547             printf("DEBUG %s/%d: random chosen method %#o\n", __FILE__, __LINE__, method);
548     }
549
550     if ( errmsg != NULL )
551         *errmsg = Errormsg;
552
553     Rec_signal=Received_signal; /* get the current number of signals received */
554 #ifdef sgi
555     Rec_callback=Received_callback;     /* get the current number of callbacks received */
556 #endif
557
558 #ifdef  CRAY
559     bzero(&status, sizeof(struct iosw));
560     bzero(&request, sizeof(struct listreq));
561     statptr[0] = &status;
562 #else
563     /* for linux or sgi */
564     bzero(&iov, sizeof(struct iovec));
565     iov.iov_base = buffer;
566     iov.iov_len = size;
567 #endif
568 #ifdef sgi
569     bzero(&aiocbp, sizeof(aiocb_t));
570     aiocbp.aio_fildes = fd;
571     aiocbp.aio_nbytes = size;
572     aiocbp.aio_buf = buffer;
573 /*    aiocbp.aio_offset = lseek( fd, 0, SEEK_CUR ); -- set below */
574     aiocbp.aio_sigevent.sigev_notify = SIGEV_NONE;
575     aiocbp.aio_sigevent.sigev_signo = 0;
576     aiocbp.aio_sigevent.sigev_func = NULL;
577     aiocbp.aio_sigevent.sigev_value.sival_int = 0;
578     aiolist[0] = &aiocbp;
579
580     if( (ret = lseek( fd, 0, SEEK_CUR )) == -1 ){
581         ret = 0;
582         /* If there is an error and it is not ESPIPE then kick out the error.
583          * If the fd is a fifo then we have to make sure that
584          * lio_random_methods() didn't select pwrite/pread; if it did then
585          * switch to write/read.
586          */
587         if( errno == ESPIPE ){
588                 if( method & LIO_IO_SYNCP ){
589                         if( omethod & LIO_RANDOM ){
590                                 method &= ~LIO_IO_SYNCP;
591                                 method |= LIO_IO_SYNC;
592                                 if( Debug_level > 2 )
593                                         printf("DEBUG %s/%d: random chosen method switched to %#o for fifo\n", __FILE__, __LINE__, method );
594                         }
595                         else if( Debug_level ){
596                                 printf("DEBUG %s/%d: pwrite will fail when it writes to a fifo\n",
597                                        __FILE__, __LINE__ );
598                         }
599                 }
600                 /* else: let it ride */
601         }
602         else{
603                 sprintf(Errormsg, "%s/%d lseek(fd=%d,0,SEEK_CUR) failed, errno=%d  %s",
604                         __FILE__, __LINE__, fd, errno, strerror(errno));
605                 return -errno;
606         }
607     }
608     poffset = (off64_t)ret;
609     aiocbp.aio_offset = ret;
610
611 #endif
612
613     /*
614      * If the LIO_USE_SIGNAL bit is not set, only use the signal
615      * if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are bit.
616      * Otherwise there is not necessary a signal handler to trap
617      * the signal.
618      */
619     if ( sig && !(method & LIO_USE_SIGNAL) && 
620         ! (method & LIO_WAIT_SIGTYPES) ){
621
622         sig=0;  /* ignore signal parameter */
623     }
624
625 #ifdef sgi
626     if ( sig && (method & LIO_WAIT_CBTYPES) )
627         sig=0; /* ignore signal parameter */
628 #endif
629
630     /*
631      * only setup signal hander if sig was specified and
632      * a sig wait method was specified.
633      * Doing this will change the handler for this signal.  The
634      * old signal handler will not be restored.
635      *** restoring the signal handler could be added ***
636      */
637
638     if ( sig &&  (method & LIO_WAIT_SIGTYPES) ){
639 #ifdef CRAY
640         sigctl(SCTL_REG, sig, lio_async_signal_handler);
641 #endif
642 #ifdef sgi
643         aiocbp.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
644         aiocbp.aio_sigevent.sigev_signo = sig;
645         sigset(sig, lio_async_signal_handler);
646 #endif /* sgi */
647     }
648 #ifdef sgi
649     else if( method & LIO_WAIT_CBTYPES ){
650         /* sival_int just has to be something that I can use
651          * to identify the callback, and "size" happens to be handy...
652          */
653         aiocbp.aio_sigevent.sigev_notify = SIGEV_CALLBACK;
654         aiocbp.aio_sigevent.sigev_func = lio_async_callback_handler;
655         aiocbp.aio_sigevent.sigev_value.sival_int = size;
656     }
657 #endif
658
659     /*
660      * Determine the system call that will be called and produce
661      * the string of the system call and place it in Lio_SysCall.
662      * Also update the io_type char pointer to give brief description
663      * of system call.  Execute the system call and check for
664      * system call failure.  If sync i/o, return the number of
665      * bytes written/read.
666      */
667      
668     if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
669         /*
670          * write(2) is used if LIO_IO_SYNC bit is set or not none
671          * of the LIO_IO_TYPES bits are set (default).
672          */
673
674         sprintf(Lio_SysCall,
675             "write(%d, buf, %d)", fd, size);
676         io_type="write";
677
678         if ( Debug_level ) {
679             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
680         }
681
682         if ((ret = write(fd, buffer, size)) == -1) {
683             sprintf(Errormsg, "%s/%d write(%d, buf, %d) ret:-1, errno=%d %s",
684                 __FILE__, __LINE__,
685                 fd, size, errno, strerror(errno));
686             return -errno;
687         }
688
689         if ( ret != size ) {
690             sprintf(Errormsg,
691                 "%s/%d write(%d, buf, %d) returned=%d",
692                     __FILE__, __LINE__,
693                     fd, size, ret);
694         }
695         else if ( Debug_level > 1 )
696             printf("DEBUG %s/%d: write completed without error (ret %d)\n",
697                 __FILE__, __LINE__, ret);
698
699         return ret;
700
701     }
702
703     else if ( method & LIO_IO_ASYNC ) {
704 #ifdef CRAY
705         sprintf(Lio_SysCall,
706             "writea(%d, buf, %d, &status, %d)", fd, size, sig);
707         io_type="writea";
708
709         if ( Debug_level ) {
710             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
711         }
712
713         sigoff();
714         if ((ret = writea(fd, buffer, size, &status, sig)) == -1) {
715             sprintf(Errormsg,
716                 "%s/%d writea(%d, buf, %d, &stat, %d) ret:-1, errno=%d %s",
717                     __FILE__, __LINE__,
718                 fd, size, sig, errno, strerror(errno));
719             sigon();
720             return -errno;
721         }
722 #endif
723 #ifdef sgi
724         sprintf(Lio_SysCall,
725             "aio_write(fildes=%d, buf, nbytes=%d, signo=%d)", fd, size, sig);
726         io_type="aio_write";
727
728         if ( Debug_level ) {
729             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
730         }
731
732         if( sig )
733                 sighold( sig );
734         if ((ret = aio_write(&aiocbp)) == -1) {
735             sprintf(Errormsg,
736                 "%s/%d aio_write(fildes=%d, buf, nbytes=%d, signo=%d) ret:-1, errno=%d %s",
737                     __FILE__, __LINE__,
738                 fd, size, sig, errno, strerror(errno));
739             if( sig )
740                 sigrelse( sig );
741             return -errno;
742         }
743 #endif
744     } /* LIO_IO_ASYNC */
745
746     else if ( method & LIO_IO_SLISTIO ) {
747 #ifdef CRAY
748         request.li_opcode = LO_WRITE;
749         request.li_fildes = fd;
750         request.li_buf = buffer;
751         request.li_nbyte = size;
752         request.li_status = &status;
753         request.li_signo = sig;
754         request.li_nstride = 0;
755         request.li_filstride = 0;
756         request.li_memstride = 0;
757
758         listio_cmd=LC_WAIT;
759         io_type="listio(2) sync write";
760
761         sprintf(Lio_SysCall, 
762                 "listio(LC_WAIT, &req, 1) LO_WRITE, fd:%d, nbyte:%d",
763                 fd, size);
764
765         if ( Debug_level ) {
766             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
767         }
768
769         sigoff();
770         if ( listio(listio_cmd, &request, 1) == -1 ) {
771             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
772                     __FILE__, __LINE__,
773                 Lio_SysCall, fd, size, errno, strerror(errno));
774             sigon();
775             return -errno;
776         }
777
778         if ( Debug_level > 1 )
779             printf("DEBUG %s/%d: %s did not return -1\n",
780                 __FILE__, __LINE__, Lio_SysCall);
781
782         ret=lio_check_asyncio(io_type, size,  &status);
783         return ret;
784
785 #endif
786 #ifdef sgi
787
788         aiocbp.aio_lio_opcode = LIO_WRITE;
789         listio_cmd=LIO_WAIT;
790         io_type="lio_listio(3) sync write";
791
792         sprintf(Lio_SysCall,
793                 "lio_listio(LIO_WAIT, aiolist, 1, NULL) LIO_WRITE, fd:%d, nbyte:%d, sig:%d",
794                 fd, size, sig );
795
796         if ( Debug_level ) {
797             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
798         }
799
800         if( sig )
801             sighold( sig );
802         if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
803             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
804                     __FILE__, __LINE__,
805                 Lio_SysCall, fd, size, errno, strerror(errno));
806             if( sig )
807                 sigrelse( sig );
808             return -errno;
809         }
810
811         if ( Debug_level > 1 )
812             printf("DEBUG %s/%d: %s did not return -1\n",
813                 __FILE__, __LINE__, Lio_SysCall);
814
815         ret=lio_check_asyncio(io_type, size,  &aiocbp, method);
816         return ret;
817 #endif
818     } /* LIO_IO_SLISTIO */
819
820     else if ( method & LIO_IO_ALISTIO ) {
821 #ifdef CRAY
822         request.li_opcode = LO_WRITE;
823         request.li_fildes = fd;
824         request.li_buf = buffer;
825         request.li_nbyte = size;
826         request.li_status = &status;
827         request.li_signo = sig;
828         request.li_nstride = 0;
829         request.li_filstride = 0;
830         request.li_memstride = 0;
831
832         listio_cmd=LC_START;
833         io_type="listio(2) async write";
834
835         sprintf(Lio_SysCall, 
836                 "listio(LC_START, &req, 1) LO_WRITE, fd:%d, nbyte:%d",
837                 fd, size);
838
839         if ( Debug_level ) {
840             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
841         }
842
843         sigoff();
844         if ( listio(listio_cmd, &request, 1) == -1 ) {
845             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
846                     __FILE__, __LINE__,
847                 Lio_SysCall, fd, size, errno, strerror(errno));
848             sigon();
849             return -errno;
850         }
851 #endif
852 #ifdef sgi
853         aiocbp.aio_lio_opcode = LIO_WRITE;
854         listio_cmd=LIO_NOWAIT;
855         io_type="lio_listio(3) async write";
856
857         sprintf(Lio_SysCall,
858                 "lio_listio(LIO_NOWAIT, aiolist, 1, NULL) LIO_WRITE, fd:%d, nbyte:%d",
859                 fd, size);
860
861         if ( Debug_level ) {
862             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
863         }
864
865         if( sig )
866                 sighold( sig );
867         if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
868             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
869                     __FILE__, __LINE__,
870                 Lio_SysCall, fd, size, errno, strerror(errno));
871             if( sig )
872                 sigrelse( sig );
873             return -errno;
874         }
875 #endif
876     }/* LIO_IO_ALISTIO */
877
878 #ifndef CRAY
879     else if ( method & LIO_IO_SYNCV ) {
880         io_type="writev(2)";
881
882         sprintf(Lio_SysCall, 
883                 "writev(%d, &iov, 1) nbyte:%d", fd, size);
884
885         if ( Debug_level ) {
886             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
887         }
888         if ((ret = writev(fd, &iov, 1)) == -1) {
889             sprintf(Errormsg, "%s/%d writev(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
890                     __FILE__, __LINE__,
891                 fd, size, errno, strerror(errno));
892             return -errno;
893         }
894
895         if ( ret != size ) {
896             sprintf(Errormsg,
897                 "%s/%d writev(%d, iov, 1) nbyte:%d returned=%d",
898                     __FILE__, __LINE__,
899                     fd, size, ret);
900         }
901         else if ( Debug_level > 1 )
902             printf("DEBUG %s/%d: writev completed without error (ret %d)\n",
903                 __FILE__, __LINE__, ret);
904
905         return ret;
906     } /* LIO_IO_SYNCV */
907 #endif
908
909 #ifdef sgi
910     else if ( method & LIO_IO_SYNCP ) {
911         io_type="pwrite(2)";
912
913         sprintf(Lio_SysCall, 
914                 "pwrite(%d, buf, %d, %lld)", fd, size, poffset);
915
916         if ( Debug_level ) {
917             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
918         }
919         if ((ret = pwrite(fd, buffer, size, poffset)) == -1) {
920             sprintf(Errormsg, "%s/%d pwrite(%d, buf, %d, %lld) ret:-1, errno=%d %s",
921                     __FILE__, __LINE__,
922                 fd, size, poffset, errno, strerror(errno));
923             return -errno;
924         }
925
926         if ( ret != size ) {
927             sprintf(Errormsg,
928                 "%s/%d pwrite(%d, buf, %d, %lld) returned=%d",
929                     __FILE__, __LINE__,
930                     fd, size, poffset, ret);
931         }
932         else if ( Debug_level > 1 )
933             printf("DEBUG %s/%d: pwrite completed without error (ret %d)\n",
934                 __FILE__, __LINE__, ret);
935
936         return ret;
937     } /* LIO_IO_SYNCP */
938 #endif
939
940     else {
941         printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
942         return -1;
943     }
944
945     /*
946      * wait for async io to complete.
947      */
948 #ifdef CRAY
949     ret=lio_wait4asyncio(method, fd, statptr);
950 #endif
951 #ifdef sgi
952     ret=lio_wait4asyncio(method, fd, &aiocbp);
953 #endif
954
955     /*
956      * If there was an error waiting for async i/o to complete,
957      * return the error value (errno) to the caller.
958      * Note: Errormsg should already have been updated.
959      */
960     if ( ret < 0 ) {
961         return ret;
962     }
963
964     /*
965      * If i/o was not waited for (may not have been completed at this time),
966      * return the size that was requested.
967      */
968     if ( ret == 1 )
969         return size;
970
971     /*
972      * check that async io was successful.
973      * Note:  if the there was an system call failure, -errno
974      * was returned and Errormsg should already have been updated.
975      * If amount i/o was different than size, Errormsg should already 
976      * have been updated but the actual i/o size if returned.
977      */
978     
979 #ifdef CRAY
980     ret=lio_check_asyncio(io_type, size, &status);
981 #endif
982 #ifdef sgi
983     ret=lio_check_asyncio(io_type, size, &aiocbp, method);
984 #endif
985
986     return ret;
987 }       /* end of lio_write_buffer */
988
989 /***********************************************************************
990  * Generic read function 
991  * This function can be used to do a read using read(2), reada(2),
992  * aio_read(3), readv(2), pread(2),
993  * or single stride listio(2)/lio_listio(3).
994  * By setting the desired bits in the method
995  * bitmask, the caller can control the type of read and the wait method
996  * that will be used.  If no io type bits are set, read will be used.
997  *
998  * If async io was attempted and no wait method bits are set then the
999  * wait method is: recall(2) for reada(2) and listio(2); aio_suspend(3) for
1000  * aio_read(3) and lio_listio(3).
1001  *
1002  * If multiple wait methods are specified, 
1003  * only one wait method will be used. The order is predetermined.
1004  *
1005  * If the call specifies a signal and one of the two signal wait methods,
1006  * a signal handler for the signal is set.  This will reset an already
1007  * set handler for this signal. 
1008  *
1009  * If the LIO_RANDOM method bit is set, this function will randomly
1010  * choose a io type and wait method from bits in the method argument.
1011  *
1012  * If an error is encountered, an error message will be generated
1013  * in a internal static buffer.  If errmsg is not NULL, it will
1014  * be updated to point to the static buffer, allowing the caller
1015  * to print the error message.
1016  *
1017  * Return Value
1018  *   If a system call fails, -errno is returned.
1019  *   If LIO_WAIT_NONE bit is set, the return value is the return value
1020  *   of the system call.
1021  *   If the io did not fail, the amount of data written is returned.
1022  *      If the size the system call say was written is different
1023  *      then what was asked to be written, errmsg is updated for
1024  *      this error condition.  The return value is still the amount
1025  *      the system call says was written.  
1026  *
1027  * (rrl 04/96)
1028  ***********************************************************************/
1029 int
1030 lio_read_buffer(fd, method, buffer, size, sig, errmsg, wrd)
1031 int fd;         /* open file descriptor */
1032 int method;     /* contains io type and wait method bitmask */
1033 char *buffer;   /* pointer to buffer */
1034 int size;       /* the size of the io */
1035 int sig;        /* signal to use if async io */
1036 char **errmsg;  /* char pointer that will be updated to point to err message */
1037 long wrd;       /* to allow future features, use zero for now */
1038 {
1039     int ret = 0;        /* syscall return or used to get random method */
1040     char *io_type;              /* Holds string of type of io */
1041 #ifndef linux
1042     int listio_cmd;             /* Holds the listio/lio_listio cmd */
1043     int omethod = method;
1044 #endif
1045 #ifdef  CRAY
1046     struct listreq request;     /* Used when a listio is wanted */
1047     struct iosw status, *statptr[1];  
1048 #else
1049     /* for linux or sgi */
1050     struct iovec iov; /* iovec for readv(2) */
1051 #endif
1052 #ifdef sgi
1053     aiocb_t aiocbp;     /* POSIX aio control block */
1054     aiocb_t *aiolist[1]; /* list of aio control blocks for lio_listio */
1055     off64_t poffset;    /* pread(2) offset */
1056 #endif
1057
1058     /*
1059      * If LIO_RANDOM bit specified, get new method randomly.
1060      */
1061     if ( method & LIO_RANDOM ) {
1062         if( Debug_level > 3 )
1063                 printf("DEBUG %s/%d: method mask to choose from: %#o\n", __FILE__, __LINE__, method );
1064         method = lio_random_methods(method);
1065         if ( Debug_level > 2 )
1066             printf("DEBUG %s/%d: random chosen method %#o\n", __FILE__, __LINE__, method);
1067     }
1068
1069     if ( errmsg != NULL )
1070         *errmsg = Errormsg;
1071
1072     Rec_signal=Received_signal; /* get the current number of signals received */
1073 #ifdef sgi
1074     Rec_callback=Received_callback;     /* get the current number of callbacks received */
1075 #endif
1076
1077 #ifdef  CRAY
1078     bzero(&status, sizeof(struct iosw));
1079     bzero(&request, sizeof(struct listreq));
1080     statptr[0] = &status;
1081 #else
1082     /* for linux or sgi */
1083     bzero(&iov, sizeof(struct iovec));
1084     iov.iov_base = buffer;
1085     iov.iov_len = size;
1086 #endif
1087 #ifdef sgi
1088     bzero(&aiocbp, sizeof(aiocb_t));
1089     aiocbp.aio_fildes = fd;
1090     aiocbp.aio_nbytes = size;
1091     aiocbp.aio_buf = buffer;
1092 /*    aiocbp.aio_offset = lseek( fd, 0, SEEK_CUR ); -- set below */
1093     aiocbp.aio_sigevent.sigev_notify = SIGEV_NONE;
1094     aiocbp.aio_sigevent.sigev_signo = 0;
1095     aiocbp.aio_sigevent.sigev_func = NULL;
1096     aiocbp.aio_sigevent.sigev_value.sival_int = 0;
1097     aiolist[0] = &aiocbp;
1098
1099     if( (ret = lseek( fd, 0, SEEK_CUR )) == -1 ){
1100         ret = 0;
1101         /* If there is an error and it is not ESPIPE then kick out the error.
1102          * If the fd is a fifo then we have to make sure that
1103          * lio_random_methods() didn't select pwrite/pread; if it did then
1104          * switch to write/read.
1105          */
1106         if( errno == ESPIPE ){
1107                 if( method & LIO_IO_SYNCP ){
1108                         if( omethod & LIO_RANDOM ){
1109                                 method &= ~LIO_IO_SYNCP;
1110                                 method |= LIO_IO_SYNC;
1111                                 if( Debug_level > 2 )
1112                                         printf("DEBUG %s/%d: random chosen method switched to %#o for fifo\n", __FILE__, __LINE__, method );
1113                         }
1114                         else if( Debug_level ){
1115                                 printf("DEBUG %s/%d: pread will fail when it reads from a fifo\n",
1116                                        __FILE__, __LINE__ );
1117                         }
1118                 }
1119                 /* else: let it ride */
1120         }
1121         else{
1122                 sprintf(Errormsg, "%s/%d lseek(fd=%d,0,SEEK_CUR) failed, errno=%d  %s",
1123                         __FILE__, __LINE__, fd, errno, strerror(errno));
1124                 return -errno;
1125         }
1126     }
1127     poffset = (off64_t)ret;
1128     aiocbp.aio_offset = ret;
1129
1130 #endif
1131
1132     /*
1133      * If the LIO_USE_SIGNAL bit is not set, only use the signal
1134      * if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are set.
1135      * Otherwise there is not necessarily a signal handler to trap
1136      * the signal.
1137      */
1138     if ( sig && !(method & LIO_USE_SIGNAL) &&
1139         ! (method & LIO_WAIT_SIGTYPES) ){
1140
1141         sig=0;  /* ignore signal parameter */
1142     }
1143
1144 #ifdef sgi
1145     if ( sig && (method & LIO_WAIT_CBTYPES) )
1146         sig=0; /* ignore signal parameter */
1147 #endif
1148
1149     /*
1150      * only setup signal hander if sig was specified and
1151      * a sig wait method was specified.
1152      * Doing this will change the handler for this signal.  The
1153      * old signal handler will not be restored.
1154      *** restoring the signal handler could be added ***
1155      */
1156
1157     if ( sig &&  (method & LIO_WAIT_SIGTYPES) ){
1158 #ifdef CRAY
1159             sigctl(SCTL_REG, sig, lio_async_signal_handler);
1160 #endif
1161 #ifdef sgi
1162             aiocbp.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
1163             aiocbp.aio_sigevent.sigev_signo = sig;
1164             sigset(sig, lio_async_signal_handler);
1165 #endif /* CRAY */
1166     }
1167 #ifdef sgi
1168     else if( method & LIO_WAIT_CBTYPES ){
1169             aiocbp.aio_sigevent.sigev_notify = SIGEV_CALLBACK;
1170             aiocbp.aio_sigevent.sigev_func = lio_async_callback_handler;
1171             /* sival_int just has to be something that I can use
1172              * to identify the callback, and "size" happens to be handy...
1173              */
1174             aiocbp.aio_sigevent.sigev_value.sival_int = size;
1175     }
1176 #endif
1177
1178     /*
1179      * Determine the system call that will be called and produce
1180      * the string of the system call and place it in Lio_SysCall.
1181      * Also update the io_type char pointer to give brief description
1182      * of system call.  Execute the system call and check for
1183      * system call failure.  If sync i/o, return the number of
1184      * bytes written/read.
1185      */
1186      
1187     if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
1188         /*
1189          * read(2) is used if LIO_IO_SYNC bit is set or not none
1190          * of the LIO_IO_TYPES bits are set (default).
1191          */
1192
1193         sprintf(Lio_SysCall,
1194             "read(%d, buf, %d)", fd, size);
1195         io_type="read";
1196
1197         if ( Debug_level ) {
1198             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1199         }
1200
1201         if ((ret = read(fd, buffer, size)) == -1) {
1202             sprintf(Errormsg, "%s/%d read(%d, buf, %d) ret:-1, errno=%d %s",
1203                     __FILE__, __LINE__,
1204                 fd, size, errno, strerror(errno));
1205             return -errno;
1206         }
1207
1208         if ( ret != size ) {
1209             sprintf(Errormsg,
1210                 "%s/%d read(%d, buf, %d) returned=%d",
1211                     __FILE__, __LINE__,
1212                     fd, size, ret);
1213         }
1214         else if ( Debug_level > 1 )
1215             printf("DEBUG %s/%d: read completed without error (ret %d)\n",
1216                 __FILE__, __LINE__, ret);
1217
1218         return ret;
1219
1220     }
1221
1222     else if ( method & LIO_IO_ASYNC ) {
1223 #ifdef CRAY
1224         sprintf(Lio_SysCall,
1225             "reada(%d, buf, %d, &status, %d)", fd, size, sig);
1226         io_type="reada";
1227
1228         if ( Debug_level ) {
1229             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1230         }
1231
1232         sigoff();
1233         if ((ret = reada(fd, buffer, size, &status, sig)) == -1) {
1234             sprintf(Errormsg,
1235                 "%s/%d reada(%d, buf, %d, &stat, %d) ret:-1, errno=%d %s",
1236                     __FILE__, __LINE__,
1237                 fd, size, sig, errno, strerror(errno));
1238             sigon();
1239             return -errno;
1240         }
1241 #endif
1242 #ifdef sgi
1243         sprintf(Lio_SysCall,
1244             "aio_read(fildes=%d, buf, nbytes=%d, signo=%d)", fd, size, sig);
1245         io_type="aio_read";
1246
1247         if ( Debug_level ) {
1248             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1249         }
1250
1251         if( sig )
1252                 sighold( sig );
1253         if ((ret = aio_read(&aiocbp)) == -1) {
1254             sprintf(Errormsg,
1255                 "%s/%d aio_read(fildes=%d, buf, nbytes=%d, signo=%d) ret:-1, errno=%d %s",
1256                     __FILE__, __LINE__,
1257                 fd, size, sig, errno, strerror(errno));
1258             if( sig )
1259                 sigrelse( sig );
1260             return -errno;
1261         }
1262 #endif
1263     } /* LIO_IO_ASYNC */
1264
1265     else if ( method & LIO_IO_SLISTIO ) {
1266 #ifdef CRAY
1267         request.li_opcode = LO_READ;
1268         request.li_fildes = fd;
1269         request.li_buf = buffer;
1270         request.li_nbyte = size;
1271         request.li_status = &status;
1272         request.li_signo = sig;
1273         request.li_nstride = 0;
1274         request.li_filstride = 0;
1275         request.li_memstride = 0;
1276
1277         listio_cmd=LC_WAIT;
1278         io_type="listio(2) sync read";
1279
1280         sprintf(Lio_SysCall, 
1281                 "listio(LC_WAIT, &req, 1) LO_READ, fd:%d, nbyte:%d",
1282                 fd, size);
1283
1284         if ( Debug_level ) {
1285             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1286         }
1287
1288         sigoff();
1289         if ( listio(listio_cmd, &request, 1) == -1 ) {
1290             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
1291                     __FILE__, __LINE__,
1292                 Lio_SysCall, fd, size, errno, strerror(errno));
1293             sigon();
1294             return -errno;
1295         }
1296
1297         if ( Debug_level > 1 )
1298             printf("DEBUG %s/%d: %s did not return -1\n",
1299                 __FILE__, __LINE__, Lio_SysCall);
1300
1301         ret=lio_check_asyncio(io_type, size,  &status);
1302         return ret;
1303 #endif
1304 #ifdef sgi
1305         aiocbp.aio_lio_opcode = LIO_READ;
1306         listio_cmd=LIO_WAIT;
1307         io_type="lio_listio(3) sync read";
1308
1309         sprintf(Lio_SysCall, 
1310                 "lio_listio(LIO_WAIT, aiolist, 1, NULL) LIO_READ, fd:%d, nbyte:%d",
1311                 fd, size);
1312
1313         if ( Debug_level ) {
1314             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1315         }
1316
1317         if( sig )
1318                 sighold( sig );
1319         if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
1320             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
1321                     __FILE__, __LINE__,
1322                 Lio_SysCall, fd, size, errno, strerror(errno));
1323             if( sig )
1324                 sigrelse( sig );
1325             return -errno;
1326         }
1327
1328         if ( Debug_level > 1 )
1329             printf("DEBUG %s/%d: %s did not return -1\n",
1330                 __FILE__, __LINE__, Lio_SysCall);
1331
1332         ret=lio_check_asyncio(io_type, size,  &aiocbp, method);
1333         return ret;
1334 #endif
1335     }/* LIO_IO_SLISTIO */
1336
1337     else if ( method & LIO_IO_ALISTIO ) {
1338 #ifdef CRAY
1339         request.li_opcode = LO_READ;
1340         request.li_fildes = fd;
1341         request.li_buf = buffer;
1342         request.li_nbyte = size;
1343         request.li_status = &status;
1344         request.li_signo = sig;
1345         request.li_nstride = 0;
1346         request.li_filstride = 0;
1347         request.li_memstride = 0;
1348
1349         listio_cmd=LC_START;
1350         io_type="listio(2) async read";
1351
1352         sprintf(Lio_SysCall, 
1353                 "listio(LC_START, &req, 1) LO_READ, fd:%d, nbyte:%d",
1354                 fd, size);
1355
1356         if ( Debug_level ) {
1357             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1358         }
1359
1360         sigoff();
1361         if ( listio(listio_cmd, &request, 1) == -1 ) {
1362             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
1363                     __FILE__, __LINE__,
1364                 Lio_SysCall, fd, size, errno, strerror(errno));
1365             sigon();
1366             return -errno;
1367         }
1368 #endif
1369 #ifdef sgi
1370         aiocbp.aio_lio_opcode = LIO_READ;
1371         listio_cmd=LIO_NOWAIT;
1372         io_type="lio_listio(3) async read";
1373
1374         sprintf(Lio_SysCall, 
1375                 "lio_listio(LIO_NOWAIT, aiolist, 1, NULL) LIO_READ, fd:%d, nbyte:%d",
1376                 fd, size);
1377
1378         if ( Debug_level ) {
1379             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1380         }
1381
1382         if( sig )
1383                 sighold( sig );
1384         if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
1385             sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
1386                     __FILE__, __LINE__,
1387                 Lio_SysCall, fd, size, errno, strerror(errno));
1388             if( sig )
1389                 sigrelse( sig );
1390             return -errno;
1391         }
1392 #endif
1393     } /* LIO_IO_ALISTIO */
1394
1395 #ifndef CRAY
1396     else if ( method & LIO_IO_SYNCV ) {
1397         io_type="readv(2)";
1398
1399         sprintf(Lio_SysCall, 
1400                 "readv(%d, &iov, 1) nbyte:%d", fd, size);
1401
1402         if ( Debug_level ) {
1403             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1404         }
1405         if ((ret = readv(fd, &iov, 1)) == -1) {
1406             sprintf(Errormsg, "%s/%d readv(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
1407                     __FILE__, __LINE__,
1408                 fd, size, errno, strerror(errno));
1409             return -errno;
1410         }
1411
1412         if ( ret != size ) {
1413             sprintf(Errormsg,
1414                 "%s/%d readv(%d, iov, 1) nbyte:%d returned=%d",
1415                     __FILE__, __LINE__,
1416                     fd, size, ret);
1417         }
1418         else if ( Debug_level > 1 )
1419             printf("DEBUG %s/%d: readv completed without error (ret %d)\n",
1420                 __FILE__, __LINE__, ret);
1421
1422         return ret;
1423     } /* LIO_IO_SYNCV */
1424 #endif
1425
1426 #ifdef sgi
1427     else if ( method & LIO_IO_SYNCP ) {
1428         io_type="pread(2)";
1429
1430         sprintf(Lio_SysCall, 
1431                 "pread(%d, buf, %d, %lld)", fd, size, poffset);
1432
1433         if ( Debug_level ) {
1434             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
1435         }
1436         if ((ret = pread(fd, buffer, size, poffset)) == -1) {
1437             sprintf(Errormsg, "%s/%d pread(%d, buf, %d, %lld) ret:-1, errno=%d %s",
1438                     __FILE__, __LINE__,
1439                 fd, size, poffset, errno, strerror(errno));
1440             return -errno;
1441         }
1442
1443         if ( ret != size ) {
1444             sprintf(Errormsg,
1445                 "%s/%d pread(%d, buf, %d, %lld) returned=%d",
1446                     __FILE__, __LINE__,
1447                     fd, size, poffset, ret);
1448         }
1449         else if ( Debug_level > 1 )
1450             printf("DEBUG %s/%d: pread completed without error (ret %d)\n",
1451                 __FILE__, __LINE__, ret);
1452
1453         return ret;
1454     } /* LIO_IO_SYNCP */
1455 #endif
1456
1457     else {
1458         printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
1459         return -1;
1460     }
1461
1462     /*
1463      * wait for async io to complete.
1464      * Note: Sync io should have returned prior to getting here.
1465      */
1466 #ifdef CRAY
1467     ret=lio_wait4asyncio(method, fd, statptr);
1468 #endif
1469 #ifdef sgi
1470     ret=lio_wait4asyncio(method, fd, &aiocbp);
1471 #endif
1472
1473     /*
1474      * If there was an error waiting for async i/o to complete,
1475      * return the error value (errno) to the caller.
1476      * Note: Errormsg should already have been updated.
1477      */
1478     if ( ret < 0 ) {
1479         return ret;
1480     }
1481
1482     /*
1483      * If i/o was not waited for (may not have been completed at this time),
1484      * return the size that was requested.
1485      */
1486     if ( ret == 1 )
1487         return size;
1488
1489     /*
1490      * check that async io was successful.
1491      * Note:  if the there was an system call failure, -errno
1492      * was returned and Errormsg should already have been updated.
1493      * If amount i/o was different than size, Errormsg should already 
1494      * have been updated but the actual i/o size if returned.
1495      */
1496     
1497 #ifdef CRAY
1498     ret=lio_check_asyncio(io_type, size, &status);
1499 #endif
1500 #ifdef sgi
1501     ret=lio_check_asyncio(io_type, size, &aiocbp, method);
1502 #endif
1503
1504     return ret;
1505 }       /* end of lio_read_buffer */
1506
1507
1508 #ifndef linux
1509 /***********************************************************************
1510  * This function will check that async io was successful.
1511  * It can also be used to check sync listio since it uses the
1512  * same method.
1513  *
1514  * Return Values
1515  *  If status.sw_error is set, -status.sw_error is returned.
1516  *  Otherwise sw_count's field value is returned.
1517  *
1518  * (rrl 04/96)
1519  ***********************************************************************/
1520 int
1521 #ifdef CRAY
1522 lio_check_asyncio(char *io_type, int size, struct iosw *status)
1523 #else
1524 lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
1525 #endif
1526 {
1527     int ret;
1528
1529 #ifdef CRAY
1530     if ( status->sw_error ) {
1531         sprintf(Errormsg,
1532             "%s/%d %s, sw_error set = %d %s, sw_count = %d",
1533                 __FILE__, __LINE__, io_type,
1534             status->sw_error, strerror(status->sw_error), status->sw_count);
1535         return -status->sw_error;
1536     }
1537     else if ( status->sw_count != size ) {
1538         sprintf(Errormsg,
1539             "%s/%d %s, sw_count not as expected(%d), but actual:%d",
1540                 __FILE__, __LINE__, io_type,
1541             size, status->sw_count);
1542     }
1543     else if ( Debug_level > 1 ) {
1544         printf("DEBUG %s/%d: %s completed without error (sw_error == 0, sw_count == %d)\n",
1545             __FILE__, __LINE__, io_type, status->sw_count);
1546     }
1547
1548     return status->sw_count;
1549
1550 #else
1551
1552     int cnt = 1;
1553
1554     /* The I/O may have been synchronous with signal completion.  It doesn't
1555      * make sense, but the combination could be generated.  Release the
1556      * completion signal here otherwise it'll hang around and bite us
1557      * later.
1558      */
1559     if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
1560         sigrelse( aiocbp->aio_sigevent.sigev_signo );
1561
1562     ret = aio_error( aiocbp );
1563
1564     while( ret == EINPROGRESS ){
1565         ret = aio_error( aiocbp );
1566         ++cnt;
1567     }
1568     if( cnt > 1 ){
1569         sprintf(Errormsg,
1570                 "%s/%d %s, aio_error had to loop on EINPROGRESS, cnt=%d; random method %#o; sigev_notify=%s",
1571                 __FILE__, __LINE__, io_type, cnt, method,
1572                 (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
1573                  aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
1574                  aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
1575                  "unknown") );
1576         return -ret;
1577     }
1578
1579     if( ret != 0 ){
1580         sprintf(Errormsg,
1581                 "%s/%d %s, aio_error = %d %s; random method %#o",
1582                 __FILE__, __LINE__, io_type,
1583                 ret, strerror(ret),
1584                 method );
1585         return -ret;
1586     }
1587     ret = aio_return( aiocbp );
1588     if( ret != size ){
1589         sprintf(Errormsg,
1590                 "%s/%d %s, aio_return not as expected(%d), but actual:%d",
1591                 __FILE__, __LINE__, io_type,
1592                 size, ret);
1593
1594 #ifdef BUG1_workaround
1595         if( ret == 0 ){
1596                 ret = size;
1597                 if( Debug_level > 1 ){
1598                         printf("WARN %s/%d: %s completed with bug1_workaround (aio_error == 0, aio_return now == %d)\n",
1599                                __FILE__, __LINE__, io_type, ret);
1600                 }
1601         }
1602 #endif /* BUG1_workaround */
1603
1604     }
1605     else if( Debug_level > 1 ){
1606         printf("DEBUG %s/%d: %s completed without error (aio_error == 0, aio_return == %d)\n",
1607             __FILE__, __LINE__, io_type, ret);
1608     }
1609
1610     return ret;
1611
1612 #endif
1613
1614 } /* end of lio_check_asyncio */
1615
1616
1617 /***********************************************************************
1618  *
1619  * This function will wait for async io to complete.
1620  * If multiple wait methods are specified, the order is predetermined
1621  * to LIO_WAIT_RECALL,
1622  * LIO_WAIT_ACTIVE, LIO_WAIT_SIGPAUSE, LIO_WAIT_SIGACTIVE,
1623  * then LIO_WAIT_NONE.
1624  *
1625  * If no wait method was specified the default wait method is: recall(2)
1626  * or aio_suspend(3), as appropriate.
1627  *
1628  * Return Values
1629  *      <0: errno of failed recall
1630  *      0 : async io was completed
1631  *      1 : async was not waited for, io may not have completed.
1632  *
1633  * (rrl 04/96)
1634  ***********************************************************************/
1635 int
1636 #ifdef CRAY
1637 lio_wait4asyncio(int method, int fd, struct iosw **statptr)
1638 #else
1639 lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
1640 #endif
1641 {
1642     int cnt;
1643 #ifdef sgi
1644     int ret;
1645     const aiocb_t *aioary[1]; 
1646 #endif
1647
1648     if ( (method & LIO_WAIT_RECALL)
1649 #ifdef sgi
1650         || (method & LIO_WAIT_CBSUSPEND) 
1651         || (method & LIO_WAIT_SIGSUSPEND) 
1652 #endif
1653         || ((method & LIO_WAIT_TYPES) == 0) ){
1654         /*
1655          * If method has LIO_WAIT_RECALL bit set or method does
1656          * not have any wait method bits set (default), use recall/aio_suspend.
1657          */
1658 #ifdef CRAY
1659         if ( Debug_level > 2 )
1660             printf("DEBUG %s/%d: wait method : recall\n", __FILE__, __LINE__);
1661         sigon();
1662         if ( recall(fd, 1, statptr) ) {
1663             sprintf(Errormsg, "%s/%d recall(%d, 1, stat) failed, errno:%d %s",
1664                     __FILE__, __LINE__,
1665                 fd, errno, strerror(errno));
1666             return -errno;
1667         }
1668 #else
1669         if ( Debug_level > 2 )
1670             printf("DEBUG %s/%d: wait method : aio_suspend, sigev_notify=%s\n", __FILE__, __LINE__,
1671                 (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
1672                  aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
1673                  aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
1674                  "unknown") );
1675
1676         aioary[0] = aiocbp;
1677         ret = aio_suspend( aioary, 1, NULL );
1678         if( (ret == -1) && (errno == EINTR) ){
1679                 if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ){
1680                         if( Debug_level > 2 ){
1681                                 printf("DEBUG %s/%d: aio_suspend received EINTR, sigev_notify=SIGEV_SIGNAL -- ok\n",
1682                                        __FILE__, __LINE__ );
1683                         }
1684                 }
1685                 else {
1686                         sprintf(Errormsg, "%s/%d aio_suspend received EINTR, sigev_notify=%s, not ok\n",
1687                                 __FILE__, __LINE__,
1688                                 (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
1689                                  aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
1690                                  aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
1691                                  "unknown") );
1692                         return -errno;
1693                 }
1694         }
1695         else if ( ret ) {
1696             sprintf(Errormsg, "%s/%d aio_suspend(fildes=%d, aioary, 1, NULL) failed, errno:%d %s",
1697                     __FILE__, __LINE__,
1698                 fd, errno, strerror(errno));
1699             return -errno;
1700         }
1701 #endif
1702
1703     } else if ( method & LIO_WAIT_ACTIVE ) {
1704         if ( Debug_level > 2 )
1705             printf("DEBUG %s/%d: wait method : active\n", __FILE__, __LINE__);
1706 #ifdef CRAY
1707         sigon();
1708         /* 
1709          * loop until sw_flag, sw_count or sw_error field elements
1710          * change to non-zero.
1711          */
1712         cnt=0;
1713         while ( (*statptr)->sw_flag == 0 && 
1714                 (*statptr)->sw_count == 0 &&
1715                 (*statptr)->sw_error == 0 ) {
1716            cnt++;
1717         }
1718 #else
1719         /* loop while aio_error() returns EINPROGRESS */
1720         cnt=0;
1721         while(1){
1722                 ret = aio_error( aiocbp );
1723                 if( (ret == 0) || (ret != EINPROGRESS) ){
1724                         break;
1725                 }
1726                 ++cnt;
1727         }
1728
1729 #endif
1730         if ( Debug_level > 5 && cnt && (cnt % 50) == 0 )
1731                 printf("DEBUG %s/%d: wait active cnt = %d\n",
1732                     __FILE__, __LINE__, cnt);
1733
1734     } else if ( method & LIO_WAIT_SIGPAUSE ) {
1735         if ( Debug_level > 2 )
1736             printf("DEBUG %s/%d: wait method : sigpause\n", __FILE__, __LINE__);
1737 #ifdef sgi
1738         /* note: don't do the sigon() for CRAY in this case.  why? -- roehrich 6/11/97 */
1739         if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
1740                 sigrelse( aiocbp->aio_sigevent.sigev_signo );
1741         else {
1742                 printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n", __FILE__, __LINE__ );
1743                 return -1;
1744         }
1745 #endif
1746         pause();
1747
1748     } else if ( method & LIO_WAIT_SIGACTIVE ) {
1749         if ( Debug_level > 2 )
1750             printf("DEBUG %s/%d: wait method : sigactive\n", __FILE__, __LINE__);
1751 #ifdef CRAY
1752         sigon();
1753 #else
1754         if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
1755                 sigrelse( aiocbp->aio_sigevent.sigev_signo );
1756         else {
1757                 printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n", __FILE__, __LINE__ );
1758                 return -1;
1759         }
1760 #endif
1761         /* loop waiting for signal */
1762         while ( Received_signal == Rec_signal ){
1763 #ifdef CRAY
1764                 sigon();
1765 #else
1766                 sigrelse( aiocbp->aio_sigevent.sigev_signo );
1767 #endif
1768         }
1769
1770     } else if ( method & LIO_WAIT_NONE ) {
1771         if ( Debug_level > 2 )
1772             printf("DEBUG %s/%d: wait method : none\n", __FILE__, __LINE__);
1773         /* It's broken because the aiocb/iosw is an automatic variable in
1774          * lio_{read,write}_buffer, so when the function returns and the
1775          * I/O completes there will be nowhere to write the I/O status.
1776          * It doesn't cause a problem on unicos--probably because of some
1777          * compiler quirk, or an accident.  It causes POSIX async I/O
1778          * to core dump some threads.   spr/pv 705909.  6/27/97 roehrich
1779          */
1780         sprintf(Errormsg, "%s/%d LIO_WAIT_NONE was selected (this is broken)\n",
1781                 __FILE__, __LINE__ );
1782 #ifdef CRAY
1783         sigon();
1784 #endif
1785 /*        return 1;*/
1786         return -1;
1787     }
1788     else {
1789         if( Debug_level > 2 )
1790             printf("DEBUG %s/%d: no wait method was chosen\n", __FILE__, __LINE__ );
1791         return -1;
1792     }
1793
1794     return 0;
1795
1796 } /* end of lio_wait4asyncio */
1797
1798 #endif /* ifndef linux */
1799
1800 #if UNIT_TEST
1801 /***********************************************************************
1802  * The following code is provided as unit test.
1803  * Just define add "-DUNIT_TEST=1" to the cc line.
1804  * 
1805  * (rrl 04/96)
1806  ***********************************************************************/
1807 struct unit_info_t {
1808     int method;
1809     int sig;
1810     char *str;
1811 }  Unit_info[] = {
1812     { LIO_IO_SYNC, 0, "sync io" },
1813     { LIO_IO_SYNCV, 0, "sync readv/writev" },
1814     { LIO_IO_SYNCP, 0, "sync pread/pwrite" },
1815     { LIO_IO_ASYNC, 0, "async io, def wait" },
1816     { LIO_IO_SLISTIO,     0, "sync listio" },
1817     { LIO_IO_ALISTIO,     0, "async listio, def wait" },
1818     { LIO_IO_ASYNC|LIO_WAIT_ACTIVE,     0, "async active" },
1819     { LIO_IO_ASYNC|LIO_WAIT_RECALL,     0, "async recall/suspend" },
1820     { LIO_IO_ASYNC|LIO_WAIT_SIGPAUSE,   SIGUSR1, "async sigpause" },
1821     { LIO_IO_ASYNC|LIO_WAIT_SIGACTIVE,  SIGUSR1, "async sigactive" },
1822     { LIO_IO_ALISTIO|LIO_WAIT_ACTIVE,     0, "async listio active" },
1823     { LIO_IO_ALISTIO|LIO_WAIT_RECALL,     0, "async listio recall" },
1824     { LIO_IO_ALISTIO|LIO_WAIT_SIGACTIVE,  SIGUSR1, "async listio sigactive" },
1825     { LIO_IO_ALISTIO|LIO_WAIT_SIGPAUSE,  SIGUSR1, "async listio sigpause" },
1826     { LIO_IO_ASYNC,     SIGUSR2, "async io, def wait, sigusr2" },
1827     { LIO_IO_ALISTIO,   SIGUSR2, "async listio, def wait, sigusr2" },
1828 };
1829
1830 int
1831 main(argc, argv)
1832 int argc;
1833 char **argv;
1834 {
1835     extern char *optarg;
1836     extern int optind;
1837
1838     int fd;
1839     char *err;
1840     char buffer[4096];
1841     int size=4096;
1842     int ret;
1843     int ind;
1844     int iter=3;
1845     int method;
1846     int exit_status = 0;
1847     int c;
1848     int i;
1849     char *symbols = NULL;
1850     int die_on_err = 0;
1851
1852     while( (c = getopt(argc,argv,"s:di:")) != -1 ){
1853         switch(c){
1854         case 's': symbols = optarg; break;
1855         case 'd': ++die_on_err; break;
1856         case 'i': iter = atoi(optarg); break;
1857         }
1858     }
1859
1860     if ((fd=open("unit_test_file", O_CREAT|O_RDWR|O_TRUNC, 0777)) == -1 ) {
1861         perror("open(unit_test_file, O_CREAT|O_RDWR|O_TRUNC, 0777) failed");
1862         exit(1);
1863     }
1864
1865     Debug_level=9;
1866
1867     if ( symbols != NULL ) {
1868         if ( (method=lio_parse_io_arg2(symbols,  &err)) == -1 ){
1869             printf("lio_parse_io_arg2(%s, &err) failed, bad token starting at %s\n",
1870             symbols, err);
1871             if( die_on_err )
1872                 exit(1);
1873         }
1874         else
1875             printf("lio_parse_io_arg2(%s, &err) returned %#o\n", symbols, method);
1876
1877         exit_status = 0;
1878         for(ind=0; ind < iter; ind++ ) {
1879           memset( buffer, 'A', 4096 );
1880           if( lseek(fd, 0, 0) == -1 ){
1881                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1882                        __LINE__, errno );
1883                 ++exit_status;
1884           }
1885           if ((ret=lio_write_buffer(fd, method, buffer,
1886                         size, SIGUSR1, &err, 0)) != size ) {
1887             printf("lio_write_buffer returned -1, err = %s\n", err);
1888           } else
1889             printf("lio_write_buffer returned %d\n", ret);
1890
1891           memset( buffer, 'B', 4096 );
1892           if( lseek(fd, 0, 0) == -1 ){
1893                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1894                        __LINE__, errno );
1895                 ++exit_status;
1896           }
1897           if ((ret=lio_read_buffer(fd, method, buffer,
1898                         size, SIGUSR2, &err, 0)) != size ) {
1899             printf("lio_read_buffer returned -1, err = %s\n", err);
1900           } else
1901             printf("lio_read_buffer returned %d\n", ret);
1902
1903           for( i = 0; i < 4096; ++i ){
1904                 if( buffer[i] != 'A' ){
1905                         printf("  buffer[%d] = %d\n", i, buffer[i] );
1906                         ++exit_status;
1907                         break;
1908                 }
1909           }
1910
1911           if( exit_status )
1912                 exit(exit_status);
1913
1914         }
1915
1916         unlink("unit_test_file");
1917         exit(0);
1918     }
1919
1920     for(ind=0; ind < sizeof(Unit_info)/sizeof(struct unit_info_t); ind++ ) {
1921
1922         printf("\n********* write %s ***************\n", Unit_info[ind].str);
1923         if( lseek(fd, 0, 0) == -1 ){
1924                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1925                        __LINE__, errno );
1926                 ++exit_status;
1927         }
1928
1929         memset( buffer, 'A', 4096 );
1930         if ((ret=lio_write_buffer(fd, Unit_info[ind].method, buffer,
1931                         size, Unit_info[ind].sig, &err, 0)) != size ) {
1932             printf(">>>>> lio_write_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n   err = %s\n",
1933                    Unit_info[ind].method, size, Unit_info[ind].sig, err);
1934             ++exit_status;
1935             if( die_on_err )
1936                 exit(exit_status);
1937         } else{
1938             printf("lio_write_buffer returned %d\n", ret);
1939         }
1940
1941         printf("\n********* read %s ***************\n", Unit_info[ind].str);
1942         if( lseek(fd, 0, 0) == -1 ){
1943                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1944                        __LINE__, errno );
1945                 ++exit_status;
1946         }
1947         memset( buffer, 'B', 4096 );
1948         if ((ret=lio_read_buffer(fd, Unit_info[ind].method, buffer,
1949                         size, Unit_info[ind].sig, &err, 0)) != size ) {
1950             printf(">>>>> lio_read_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n   err = %s\n",
1951                    Unit_info[ind].method, size, Unit_info[ind].sig, err);
1952             ++exit_status;
1953             if( die_on_err )
1954                 exit(exit_status);
1955         } else {
1956             printf("lio_read_buffer returned %d\n", ret);
1957         }
1958
1959           for( i = 0; i < 4096; ++i ){
1960                 if( buffer[i] != 'A' ){
1961                         printf("  buffer[%d] = %d\n", i, buffer[i] );
1962                         ++exit_status;
1963                         if( die_on_err )
1964                                 exit(exit_status);
1965                         break;
1966                 }
1967           }
1968
1969         fflush(stdout);
1970         fflush(stderr);
1971         sleep(1);
1972
1973     }
1974
1975     unlink("unit_test_file");
1976
1977     exit(exit_status);
1978 }
1979 #endif