lib/tlibio.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 /*
   7  *
   8  * Lib i/o
   9  *
  10  * This file contains several functions to doing reads and writes.
  11  * It was written so that a single function could be called in a test
  12  * program and only a io type field value would have to change to
  13  * do different types of io.  There is even a couple of functions that
  14  * will allow you to parse a string to determine the iotype.
  15  *
  16  * This file contains functions for writing/reading to/from open files
  17  * Prototypes:
  18  *
  19  * Functions declared in this module - see individual function code for
  20  * usage comments:
  21  *
  22  *  int  stride_bounds(int offset, int stride, int nstrides,
  23  *                    int bytes_per_stride, int *min, int *max);
  24
  25  *  int  lio_write_buffer(int fd, int method, char *buffer, int size,
  26  *                                              char **errmsg, long wrd);
  27  *  int  lio_read_buffer(int fd, int method, char *buffer, int size,
  28  *                                              char **errmsg, long wrd);
  29  *  int  lio_parse_io_arg1(char *string)
  30  *  void lio_help1(char *prefix);
  31  *
  32  *  int  lio_parse_io_arg2(char *string, char **badtoken)
  33  *  void lio_help2(char *prefix);
  34  *
  35  *  int  lio_set_debug(int level);
  36  *
  37  *  char Lio_SysCall[];
  38  *  struct lio_info_type Lio_info1[];
  39  *  struct lio_info_type Lio_info2[];
  40  *
  41  *  Author : Richard Logan
  42  *
  43  */
  44
  45 #include <stdio.h>
  46 #include <ctype.h>
  47 #include <fcntl.h>
  48 #include <unistd.h>
  49 #include <sys/types.h>
  50 #include <sys/stat.h>
  51 #include <sys/time.h>
  52 #include <sys/param.h>
  53 #include <errno.h>
  54 #include <sys/types.h>
  55 #include <sys/file.h>
  56 #include <signal.h>
  57 #include <sys/uio.h> /* readv(2)/writev(2) */
  58 #include <string.h>
  59 #include <strings.h>
  60 #include <stdlib.h> /* atoi, abs */
  61
  62 #include "tlibio.h"             /* defines LIO* marcos */
  63
  64 #ifndef PATH_MAX
  65 #define PATH_MAX        MAXPATHLEN
  66 #endif
  67
  68 #if 0 /* disabled until it's needed -- roehrich 6/11/97 */
  69 #define BUG1_workaround 1 /* Work around a condition where aio_return gives
  70                            * a value of zero but there is no errno followup
  71                            * and the read/write operation actually did its
  72                            * job.   spr/pv 705244
  73                            */
  74 #endif
  75
  76
  77 #ifndef linux
  78 static void lio_async_signal_handler();
  79 #endif
  80
  81 /*
  82  * Define the structure as used in lio_parse_arg1 and lio_help1
  83  */
  84 struct lio_info_type  Lio_info1[] = {
  85     { "s", LIO_IO_SYNC, "sync i/o" },
  86     { "p", LIO_IO_ASYNC|LIO_WAIT_SIGACTIVE, "async i/o using a loop to wait for a signal" },
  87     { "b", LIO_IO_ASYNC|LIO_WAIT_SIGPAUSE, "async i/o using pause" },
  88     { "a", LIO_IO_ASYNC|LIO_WAIT_RECALL, "async i/o using recall/aio_suspend" },
  89     { "r",
  90         LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
  91     { "R",
  92         LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
  93     { "l", LIO_IO_SLISTIO|LIO_WAIT_RECALL, "single stride sync listio" },
  94     { "L", LIO_IO_ALISTIO|LIO_WAIT_RECALL, "single stride async listio using recall" },
  95     { "X", LIO_IO_ALISTIO|LIO_WAIT_SIGPAUSE, "single stride async listio using pause" },
  96     { "v", LIO_IO_SYNCV, "single buffer sync readv/writev" },
  97     { "P", LIO_IO_SYNCP, "sync pread/pwrite" },
  98 };
  99
 100 /*
 101  * Define the structure used by lio_parse_arg2 and lio_help2
 102  */
 103 struct lio_info_type  Lio_info2[] = {
 104     { "sync",      LIO_IO_SYNC,         "sync i/o (read/write)"},
 105     { "async",     LIO_IO_ASYNC,        "async i/o (reada/writea/aio_read/aio_write)" },
 106     { "slistio",   LIO_IO_SLISTIO,      "single stride sync listio" },
 107     { "alistio",   LIO_IO_ALISTIO,      "single stride async listio" },
 108     { "syncv",     LIO_IO_SYNCV,        "single buffer sync readv/writev"},
 109     { "syncp",     LIO_IO_SYNCP,        "pread/pwrite"},
 110     { "active",    LIO_WAIT_ACTIVE,     "spin on status/control values" },
 111     { "recall",    LIO_WAIT_RECALL,     "use recall(2)/aio_suspend(3) to wait for i/o to complete" },
 112     { "sigactive", LIO_WAIT_SIGACTIVE,  "spin waiting for signal" },
 113     { "sigpause",  LIO_WAIT_SIGPAUSE,   "call pause(2) to wait for signal" },
 114 /* nowait is a touchy thing, it's an accident that this implementation worked at all.  6/27/97 roehrich */
 115 /*    { "nowait",    LIO_WAIT_NONE,     "do not wait for async io to complete" },*/
 116     { "random",    LIO_RANDOM,          "set random bit" },
 117     { "randomall",
 118         LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES,
 119         "all random i/o types and wait methods (except nowait)" },
 120 };
 121
 122 char Lio_SysCall[PATH_MAX];     /* string containing last i/o system call */
 123
 124 static volatile int Received_signal = 0;        /* number of signals received */
 125 static volatile int Rec_signal;
 126 static char Errormsg[500];
 127 static int Debug_level = 0;
 128
 129
 130
 131 /***********************************************************************
 132  * stride_bounds()
 133  *
 134  * Determine the bounds of a strided request, normalized to offset.  Returns
 135  * the number of bytes needed to satisfy the request, and optionally sets
 136  * *min and *max to the mininum and maximum bytes referenced, normalized
 137  * around offset.
 138  *
 139  * Returns -1 on error - the only possible error conditions are illegal values
 140  * for nstrides and/or bytes_per_stride - both parameters must be >= 0.
 141  *
 142  * (maule, 11/16/95)
 143  ***********************************************************************/
 144
 145 int
 146 stride_bounds(offset, stride, nstrides, bytes_per_stride, min, max)
 147 int     offset;
 148 int     stride;
 149 int     nstrides;
 150 int     bytes_per_stride;
 151 int     *min;
 152 int     *max;
 153 {
 154         int     nbytes, min_byte, max_byte;
 155
 156         /*
 157          * sanity checks ...
 158          */
 159
 160         if (nstrides < 0 || bytes_per_stride < 0) {
 161                 return -1;
 162         }
 163
 164         if (stride == 0) {
 165                 stride = bytes_per_stride;
 166         }
 167
 168         /*
 169          * Determine the # of bytes needed to satisfy the request.  This
 170          * value, along with the offset argument, determines the min and max
 171          * bytes referenced.
 172          */
 173
 174
 175         nbytes = abs(stride) * (nstrides-1) + bytes_per_stride;
 176
 177         if (stride < 0) {
 178                 max_byte = offset + bytes_per_stride - 1;
 179                 min_byte = max_byte - nbytes + 1;
 180         } else {
 181                 min_byte = offset;
 182                 max_byte = min_byte + nbytes - 1;
 183         }
 184
 185         if (min != NULL) {
 186                 *min = min_byte;
 187         }
 188
 189         if (max != NULL) {
 190                 *max = max_byte;
 191         }
 192
 193         return nbytes;
 194 }
 195
 196 /***********************************************************************
 197  * This function will allow someone to set the debug level.
 198  ***********************************************************************/
 199 int
 200 lio_set_debug(int level)
 201 {
 202     int old;
 203
 204     old = Debug_level;
 205     Debug_level = level;
 206     return old;
 207 }
 208
 209 /***********************************************************************
 210  * This function will parse a string and return desired io-method.
 211  * Only the first character of the string is used.
 212  *
 213  * This function does not provide for meaningful option arguments,
 214  * but it supports current growfiles/btlk interface.
 215  *
 216  *  (rrl 04/96)
 217  ***********************************************************************/
 218 int
 219 lio_parse_io_arg1(char *string)
 220 {
 221     int ind;
 222     int found=0;
 223     int mask=0;
 224
 225     /*
 226      * Determine if token is a valid string.
 227      */
 228     for(ind=0; ind<sizeof(Lio_info1)/sizeof(struct lio_info_type); ind++) {
 229         if ( strcmp(string, Lio_info1[ind].token) == 0 ) {
 230             mask |= Lio_info1[ind].bits;
 231             found = 1;
 232             break;
 233         }
 234     }
 235
 236     if ( found == 0 ) {
 237         return -1;
 238     }
 239
 240     return mask;
 241
 242 }
 243
 244 /***********************************************************************
 245  * This function will print a help message describing the characters
 246  * that can be parsed by lio_parse_io_arg1().
 247  * They will be printed one per line.
 248  *  (rrl 04/96)
 249  ***********************************************************************/
 250 void
 251 lio_help1(char *prefix)
 252 {
 253     int ind;
 254
 255     for(ind=0; ind<sizeof(Lio_info1)/sizeof(struct lio_info_type); ind++) {
 256         printf("%s %s : %s\n", prefix,
 257             Lio_info1[ind].token, Lio_info1[ind].desc);
 258     }
 259
 260     return;
 261 }
 262
 263 /***********************************************************************
 264  * This function will parse a string and return the desired io-method.
 265  * This function will take a comma separated list of io type and wait
 266  * method tokens as defined in Lio_info2[].  If a token does not match
 267  * any of the tokens in Lio_info2[], it will be coverted to a number.
 268  * If it was a number, those bits are also set.
 269  *
 270  *  (rrl 04/96)
 271  ***********************************************************************/
 272 int
 273 lio_parse_io_arg2(char *string, char **badtoken)
 274 {
 275    char *token = string;
 276    char *cc = token;
 277    char savecc;
 278    int found;
 279    int mask=0;
 280
 281    int tmp;
 282    int ind;
 283    char chr;
 284
 285    if ( token == NULL )
 286         return -1;
 287
 288    for (;;) {
 289         for (; ((*cc != ',') && (*cc != '\0')); cc++);
 290         savecc = *cc;
 291         *cc = '\0';
 292
 293         found = 0;
 294
 295         /*
 296          * Determine if token is a valid string or number and if
 297          * so, add the bits to the mask.
 298           */
 299         for(ind=0; ind<sizeof(Lio_info2)/sizeof(struct lio_info_type); ind++) {
 300             if ( strcmp(token, Lio_info2[ind].token) == 0 ) {
 301                 mask |= Lio_info2[ind].bits;
 302                 found = 1;
 303                 break;
 304             }
 305         }
 306
 307         /*
 308          * If token does not match one of the defined tokens, determine
 309          * if it is a number, if so, add the bits.
 310          */
 311         if ( !found ) {
 312             if (sscanf(token, "%i%c", &tmp, &chr) == 1 ) {
 313                 mask |= tmp;
 314                 found=1;
 315             }
 316         }
 317
 318         *cc = savecc;
 319
 320         if (!found) {  /* token is not valid */
 321             if ( badtoken != NULL)
 322                 *badtoken = token;
 323             return(-1);
 324         }
 325
 326         if (savecc == '\0')
 327             break;
 328
 329         token = ++cc;
 330     }
 331
 332     return mask;
 333 }
 334
 335 /***********************************************************************
 336  * This function will print a help message describing the tokens
 337  * that can be parsed by lio_parse_io_arg2().
 338  * It will print them one per line.
 339  *
 340  * (rrl 04/96)
 341  ***********************************************************************/
 342 void
 343 lio_help2(char *prefix)
 344 {
 345     int ind;
 346
 347     for(ind=0; ind<sizeof(Lio_info2)/sizeof(struct lio_info_type); ind++) {
 348         printf("%s %s : %s\n", prefix,
 349             Lio_info2[ind].token, Lio_info2[ind].desc);
 350     }
 351     return;
 352 }
 353
 354 #ifndef linux
 355 /***********************************************************************
 356  * This is an internal signal handler.
 357  * If the handler is called, it will increment the Received_signal
 358  * global variable.
 359  ***********************************************************************/
 360 static void
 361 lio_async_signal_handler(int sig)
 362 {
 363         if ( Debug_level )
 364             printf("DEBUG %s/%d: received signal %d, a signal caught %d times\n",
 365                 __FILE__, __LINE__, sig, Received_signal+1);
 366
 367         Received_signal++;
 368
 369         return;
 370 }
 371 #endif
 372
 373 /***********************************************************************
 374  * lio_random_methods
 375  * This function will randomly choose an io type and wait method
 376  * from set of io types and wait methods.  Since this information
 377  * is stored in a bitmask, it randomly chooses an io type from
 378  * the io type bits specified and does the same for wait methods.
 379  *
 380  * Return Value
 381  * This function will return a value with all non choosen io type
 382  * and wait method bits cleared.  The LIO_RANDOM bit is also
 383  * cleared.  All other bits are left unchanged.
 384  *
 385  * (rrl 04/96)
 386  ***********************************************************************/
 387 int
 388 lio_random_methods(long curr_mask)
 389 {
 390     int mask=0;
 391     long random_bit(long);
 392
 393     /* remove random select, io type, and wait method bits from curr_mask */
 394     mask = curr_mask & (~(LIO_IO_TYPES | LIO_WAIT_TYPES | LIO_RANDOM));
 395
 396     /* randomly select io type from specified io types */
 397     mask = mask | random_bit(curr_mask & LIO_IO_TYPES);
 398
 399     /* randomly select wait methods  from specified wait methods */
 400     mask = mask | random_bit(curr_mask & LIO_WAIT_TYPES);
 401
 402     return mask;
 403 }
 404
 405 /***********************************************************************
 406  * Generic write function
 407  * This function can be used to do a write using write(2), writea(2),
 408  * aio_write(3), writev(2), pwrite(2),
 409  * or single stride listio(2)/lio_listio(3).
 410  * By setting the desired bits in the method
 411  * bitmask, the caller can control the type of write and the wait method
 412  * that will be used.  If no io type bits are set, write will be used.
 413  *
 414  * If async io was attempted and no wait method bits are set then the
 415  * wait method is: recall(2) for writea(2) and listio(2); aio_suspend(3) for
 416  * aio_write(3) and lio_listio(3).
 417  *
 418  * If multiple wait methods are specified,
 419  * only one wait method will be used. The order is predetermined.
 420  *
 421  * If the call specifies a signal and one of the two signal wait methods,
 422  * a signal handler for the signal is set.  This will reset an already
 423  * set handler for this signal.
 424  *
 425  * If the LIO_RANDOM method bit is set, this function will randomly
 426  * choose a io type and wait method from bits in the method argument.
 427  *
 428  * If an error is encountered, an error message will be generated
 429  * in a internal static buffer.  If errmsg is not NULL, it will
 430  * be updated to point to the static buffer, allowing the caller
 431  * to print the error message.
 432  *
 433  * Return Value
 434  *   If a system call fails, -errno is returned.
 435  *   If LIO_WAIT_NONE bit is set, the return value is the return value
 436  *   of the system call.
 437  *   If the io did not fail, the amount of data written is returned.
 438  *      If the size the system call say was written is different
 439  *      then what was asked to be written, errmsg is updated for
 440  *      this error condition.  The return value is still the amount
 441  *      the system call says was written.
 442  *
 443  * (rrl 04/96)
 444  ***********************************************************************/
 445 int
 446 lio_write_buffer(fd, method, buffer, size, sig, errmsg, wrd)
 447 int fd;         /* open file descriptor */
 448 int method;     /* contains io type and wait method bitmask */
 449 char *buffer;   /* pointer to buffer */
 450 int size;       /* the size of the io */
 451 int sig;        /* signal to use if async io */
 452 char **errmsg;  /* char pointer that will be updated to point to err message */
 453 long wrd;       /* to allow future features, use zero for now */
 454 {
 455     int ret = 0;        /* syscall return or used to get random method */
 456 #ifndef linux
 457     int omethod = method;
 458     int listio_cmd;             /* Holds the listio/lio_listio cmd */
 459 #endif
 460     struct iovec iov;   /* iovec for writev(2) */
 461
 462     /*
 463      * If LIO_RANDOM bit specified, get new method randomly.
 464      */
 465     if ( method & LIO_RANDOM ) {
 466         if( Debug_level > 3 )
 467                 printf("DEBUG %s/%d: method mask to choose from: %#o\n", __FILE__, __LINE__, method );
 468         method = lio_random_methods(method);
 469         if ( Debug_level > 2 )
 470             printf("DEBUG %s/%d: random chosen method %#o\n", __FILE__, __LINE__, method);
 471     }
 472
 473     if ( errmsg != NULL )
 474         *errmsg = Errormsg;
 475
 476     Rec_signal=Received_signal; /* get the current number of signals received */
 477     bzero(&iov, sizeof(struct iovec));
 478     iov.iov_base = buffer;
 479     iov.iov_len = size;
 480
 481     /*
 482      * If the LIO_USE_SIGNAL bit is not set, only use the signal
 483      * if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are bit.
 484      * Otherwise there is not necessary a signal handler to trap
 485      * the signal.
 486      */
 487     if ( sig && !(method & LIO_USE_SIGNAL) &&
 488         ! (method & LIO_WAIT_SIGTYPES) ){
 489
 490         sig=0;  /* ignore signal parameter */
 491     }
 492
 493     /*
 494      * only setup signal hander if sig was specified and
 495      * a sig wait method was specified.
 496      * Doing this will change the handler for this signal.  The
 497      * old signal handler will not be restored.
 498      *** restoring the signal handler could be added ***
 499      */
 500
 501     /*
 502      * Determine the system call that will be called and produce
 503      * the string of the system call and place it in Lio_SysCall.
 504      * Execute the system call and check for system call failure.
 505      * If sync i/o, return the number of bytes written/read.
 506      */
 507
 508     if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
 509         /*
 510          * write(2) is used if LIO_IO_SYNC bit is set or not none
 511          * of the LIO_IO_TYPES bits are set (default).
 512          */
 513
 514         sprintf(Lio_SysCall,
 515             "write(%d, buf, %d)", fd, size);
 516
 517         if ( Debug_level ) {
 518             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
 519         }
 520
 521         if ((ret = write(fd, buffer, size)) == -1) {
 522             sprintf(Errormsg, "%s/%d write(%d, buf, %d) ret:-1, errno=%d %s",
 523                 __FILE__, __LINE__,
 524                 fd, size, errno, strerror(errno));
 525             return -errno;
 526         }
 527
 528         if ( ret != size ) {
 529             sprintf(Errormsg,
 530                 "%s/%d write(%d, buf, %d) returned=%d",
 531                     __FILE__, __LINE__,
 532                     fd, size, ret);
 533         }
 534         else if ( Debug_level > 1 )
 535             printf("DEBUG %s/%d: write completed without error (ret %d)\n",
 536                 __FILE__, __LINE__, ret);
 537
 538         return ret;
 539
 540     }
 541
 542     else if ( method & LIO_IO_SYNCV ) {
 543
 544         sprintf(Lio_SysCall,
 545                 "writev(%d, &iov, 1) nbyte:%d", fd, size);
 546
 547         if ( Debug_level ) {
 548             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
 549         }
 550         if ((ret = writev(fd, &iov, 1)) == -1) {
 551             sprintf(Errormsg, "%s/%d writev(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
 552                     __FILE__, __LINE__,
 553                 fd, size, errno, strerror(errno));
 554             return -errno;
 555         }
 556
 557         if ( ret != size ) {
 558             sprintf(Errormsg,
 559                 "%s/%d writev(%d, iov, 1) nbyte:%d returned=%d",
 560                     __FILE__, __LINE__,
 561                     fd, size, ret);
 562         }
 563         else if ( Debug_level > 1 )
 564             printf("DEBUG %s/%d: writev completed without error (ret %d)\n",
 565                 __FILE__, __LINE__, ret);
 566
 567         return ret;
 568     } /* LIO_IO_SYNCV */
 569
 570     else {
 571         printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
 572         return -1;
 573     }
 574
 575     /*
 576      * If there was an error waiting for async i/o to complete,
 577      * return the error value (errno) to the caller.
 578      * Note: Errormsg should already have been updated.
 579      */
 580     if ( ret < 0 ) {
 581         return ret;
 582     }
 583
 584     /*
 585      * If i/o was not waited for (may not have been completed at this time),
 586      * return the size that was requested.
 587      */
 588     if ( ret == 1 )
 589         return size;
 590
 591     /*
 592      * check that async io was successful.
 593      * Note:  if the there was an system call failure, -errno
 594      * was returned and Errormsg should already have been updated.
 595      * If amount i/o was different than size, Errormsg should already
 596      * have been updated but the actual i/o size if returned.
 597      */
 598
 599     return ret;
 600 }       /* end of lio_write_buffer */
 601
 602 /***********************************************************************
 603  * Generic read function
 604  * This function can be used to do a read using read(2), reada(2),
 605  * aio_read(3), readv(2), pread(2),
 606  * or single stride listio(2)/lio_listio(3).
 607  * By setting the desired bits in the method
 608  * bitmask, the caller can control the type of read and the wait method
 609  * that will be used.  If no io type bits are set, read will be used.
 610  *
 611  * If async io was attempted and no wait method bits are set then the
 612  * wait method is: recall(2) for reada(2) and listio(2); aio_suspend(3) for
 613  * aio_read(3) and lio_listio(3).
 614  *
 615  * If multiple wait methods are specified,
 616  * only one wait method will be used. The order is predetermined.
 617  *
 618  * If the call specifies a signal and one of the two signal wait methods,
 619  * a signal handler for the signal is set.  This will reset an already
 620  * set handler for this signal.
 621  *
 622  * If the LIO_RANDOM method bit is set, this function will randomly
 623  * choose a io type and wait method from bits in the method argument.
 624  *
 625  * If an error is encountered, an error message will be generated
 626  * in a internal static buffer.  If errmsg is not NULL, it will
 627  * be updated to point to the static buffer, allowing the caller
 628  * to print the error message.
 629  *
 630  * Return Value
 631  *   If a system call fails, -errno is returned.
 632  *   If LIO_WAIT_NONE bit is set, the return value is the return value
 633  *   of the system call.
 634  *   If the io did not fail, the amount of data written is returned.
 635  *      If the size the system call say was written is different
 636  *      then what was asked to be written, errmsg is updated for
 637  *      this error condition.  The return value is still the amount
 638  *      the system call says was written.
 639  *
 640  * (rrl 04/96)
 641  ***********************************************************************/
 642 int
 643 lio_read_buffer(fd, method, buffer, size, sig, errmsg, wrd)
 644 int fd;         /* open file descriptor */
 645 int method;     /* contains io type and wait method bitmask */
 646 char *buffer;   /* pointer to buffer */
 647 int size;       /* the size of the io */
 648 int sig;        /* signal to use if async io */
 649 char **errmsg;  /* char pointer that will be updated to point to err message */
 650 long wrd;       /* to allow future features, use zero for now */
 651 {
 652     int ret = 0;        /* syscall return or used to get random method */
 653 #ifndef linux
 654     int listio_cmd;             /* Holds the listio/lio_listio cmd */
 655     int omethod = method;
 656 #endif
 657     struct iovec iov; /* iovec for readv(2) */
 658
 659     /*
 660      * If LIO_RANDOM bit specified, get new method randomly.
 661      */
 662     if ( method & LIO_RANDOM ) {
 663         if( Debug_level > 3 )
 664                 printf("DEBUG %s/%d: method mask to choose from: %#o\n", __FILE__, __LINE__, method );
 665         method = lio_random_methods(method);
 666         if ( Debug_level > 2 )
 667             printf("DEBUG %s/%d: random chosen method %#o\n", __FILE__, __LINE__, method);
 668     }
 669
 670     if ( errmsg != NULL )
 671         *errmsg = Errormsg;
 672
 673     Rec_signal=Received_signal; /* get the current number of signals received */
 674     bzero(&iov, sizeof(struct iovec));
 675     iov.iov_base = buffer;
 676     iov.iov_len = size;
 677
 678     /*
 679      * If the LIO_USE_SIGNAL bit is not set, only use the signal
 680      * if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are set.
 681      * Otherwise there is not necessarily a signal handler to trap
 682      * the signal.
 683      */
 684     if ( sig && !(method & LIO_USE_SIGNAL) &&
 685         ! (method & LIO_WAIT_SIGTYPES) ){
 686
 687         sig=0;  /* ignore signal parameter */
 688     }
 689
 690     /*
 691      * only setup signal hander if sig was specified and
 692      * a sig wait method was specified.
 693      * Doing this will change the handler for this signal.  The
 694      * old signal handler will not be restored.
 695      *** restoring the signal handler could be added ***
 696      */
 697
 698     /*
 699      * Determine the system call that will be called and produce
 700      * the string of the system call and place it in Lio_SysCall.
 701      * Execute the system call and check for system call failure.
 702      * If sync i/o, return the number of bytes written/read.
 703      */
 704
 705     if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
 706         /*
 707          * read(2) is used if LIO_IO_SYNC bit is set or not none
 708          * of the LIO_IO_TYPES bits are set (default).
 709          */
 710
 711         sprintf(Lio_SysCall,
 712             "read(%d, buf, %d)", fd, size);
 713
 714         if ( Debug_level ) {
 715             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
 716         }
 717
 718         if ((ret = read(fd, buffer, size)) == -1) {
 719             sprintf(Errormsg, "%s/%d read(%d, buf, %d) ret:-1, errno=%d %s",
 720                     __FILE__, __LINE__,
 721                 fd, size, errno, strerror(errno));
 722             return -errno;
 723         }
 724
 725         if ( ret != size ) {
 726             sprintf(Errormsg,
 727                 "%s/%d read(%d, buf, %d) returned=%d",
 728                     __FILE__, __LINE__,
 729                     fd, size, ret);
 730         }
 731         else if ( Debug_level > 1 )
 732             printf("DEBUG %s/%d: read completed without error (ret %d)\n",
 733                 __FILE__, __LINE__, ret);
 734
 735         return ret;
 736
 737     }
 738
 739     else if ( method & LIO_IO_SYNCV ) {
 740
 741         sprintf(Lio_SysCall,
 742                 "readv(%d, &iov, 1) nbyte:%d", fd, size);
 743
 744         if ( Debug_level ) {
 745             printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
 746         }
 747         if ((ret = readv(fd, &iov, 1)) == -1) {
 748             sprintf(Errormsg, "%s/%d readv(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
 749                     __FILE__, __LINE__,
 750                 fd, size, errno, strerror(errno));
 751             return -errno;
 752         }
 753
 754         if ( ret != size ) {
 755             sprintf(Errormsg,
 756                 "%s/%d readv(%d, iov, 1) nbyte:%d returned=%d",
 757                     __FILE__, __LINE__,
 758                     fd, size, ret);
 759         }
 760         else if ( Debug_level > 1 )
 761             printf("DEBUG %s/%d: readv completed without error (ret %d)\n",
 762                 __FILE__, __LINE__, ret);
 763
 764         return ret;
 765     } /* LIO_IO_SYNCV */
 766
 767     else {
 768         printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
 769         return -1;
 770     }
 771
 772     /*
 773      * If there was an error waiting for async i/o to complete,
 774      * return the error value (errno) to the caller.
 775      * Note: Errormsg should already have been updated.
 776      */
 777     if ( ret < 0 ) {
 778         return ret;
 779     }
 780
 781     /*
 782      * If i/o was not waited for (may not have been completed at this time),
 783      * return the size that was requested.
 784      */
 785     if ( ret == 1 )
 786         return size;
 787
 788     /*
 789      * check that async io was successful.
 790      * Note:  if the there was an system call failure, -errno
 791      * was returned and Errormsg should already have been updated.
 792      * If amount i/o was different than size, Errormsg should already
 793      * have been updated but the actual i/o size if returned.
 794      */
 795
 796     return ret;
 797 }       /* end of lio_read_buffer */
 798
 799
 800 #ifndef linux
 801 /***********************************************************************
 802  * This function will check that async io was successful.
 803  * It can also be used to check sync listio since it uses the
 804  * same method.
 805  *
 806  * Return Values
 807  *  If status.sw_error is set, -status.sw_error is returned.
 808  *  Otherwise sw_count's field value is returned.
 809  *
 810  * (rrl 04/96)
 811  ***********************************************************************/
 812 int
 813 lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
 814 {
 815     int ret;
 816     int cnt = 1;
 817
 818     /* The I/O may have been synchronous with signal completion.  It doesn't
 819      * make sense, but the combination could be generated.  Release the
 820      * completion signal here otherwise it'll hang around and bite us
 821      * later.
 822      */
 823     if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
 824         sigrelse( aiocbp->aio_sigevent.sigev_signo );
 825
 826     ret = aio_error( aiocbp );
 827
 828     while( ret == EINPROGRESS ){
 829         ret = aio_error( aiocbp );
 830         ++cnt;
 831     }
 832     if( cnt > 1 ){
 833         sprintf(Errormsg,
 834                 "%s/%d %s, aio_error had to loop on EINPROGRESS, cnt=%d; random method %#o; sigev_notify=%s",
 835                 __FILE__, __LINE__, io_type, cnt, method,
 836                 (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
 837                  aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
 838                  aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
 839                  "unknown") );
 840         return -ret;
 841     }
 842
 843     if( ret != 0 ){
 844         sprintf(Errormsg,
 845                 "%s/%d %s, aio_error = %d %s; random method %#o",
 846                 __FILE__, __LINE__, io_type,
 847                 ret, strerror(ret),
 848                 method );
 849         return -ret;
 850     }
 851     ret = aio_return( aiocbp );
 852     if( ret != size ){
 853         sprintf(Errormsg,
 854                 "%s/%d %s, aio_return not as expected(%d), but actual:%d",
 855                 __FILE__, __LINE__, io_type,
 856                 size, ret);
 857
 858 #ifdef BUG1_workaround
 859         if( ret == 0 ){
 860                 ret = size;
 861                 if( Debug_level > 1 ){
 862                         printf("WARN %s/%d: %s completed with bug1_workaround (aio_error == 0, aio_return now == %d)\n",
 863                                __FILE__, __LINE__, io_type, ret);
 864                 }
 865         }
 866 #endif /* BUG1_workaround */
 867
 868     }
 869     else if( Debug_level > 1 ){
 870         printf("DEBUG %s/%d: %s completed without error (aio_error == 0, aio_return == %d)\n",
 871             __FILE__, __LINE__, io_type, ret);
 872     }
 873
 874     return ret;
 875
 876 } /* end of lio_check_asyncio */
 877
 878
 879 /***********************************************************************
 880  *
 881  * This function will wait for async io to complete.
 882  * If multiple wait methods are specified, the order is predetermined
 883  * to LIO_WAIT_RECALL,
 884  * LIO_WAIT_ACTIVE, LIO_WAIT_SIGPAUSE, LIO_WAIT_SIGACTIVE,
 885  * then LIO_WAIT_NONE.
 886  *
 887  * If no wait method was specified the default wait method is: recall(2)
 888  * or aio_suspend(3), as appropriate.
 889  *
 890  * Return Values
 891  *      <0: errno of failed recall
 892  *      0 : async io was completed
 893  *      1 : async was not waited for, io may not have completed.
 894  *
 895  * (rrl 04/96)
 896  ***********************************************************************/
 897 int
 898 lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
 899 {
 900     int cnt;
 901
 902     if ( (method & LIO_WAIT_RECALL)
 903         || ((method & LIO_WAIT_TYPES) == 0) ){
 904         /*
 905          * If method has LIO_WAIT_RECALL bit set or method does
 906          * not have any wait method bits set (default), use recall/aio_suspend.
 907          */
 908         if ( Debug_level > 2 )
 909             printf("DEBUG %s/%d: wait method : aio_suspend, sigev_notify=%s\n", __FILE__, __LINE__,
 910                 (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
 911                  aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
 912                  aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
 913                  "unknown") );
 914
 915         aioary[0] = aiocbp;
 916         ret = aio_suspend( aioary, 1, NULL );
 917         if( (ret == -1) && (errno == EINTR) ){
 918                 if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ){
 919                         if( Debug_level > 2 ){
 920                                 printf("DEBUG %s/%d: aio_suspend received EINTR, sigev_notify=SIGEV_SIGNAL -- ok\n",
 921                                        __FILE__, __LINE__ );
 922                         }
 923                 }
 924                 else {
 925                         sprintf(Errormsg, "%s/%d aio_suspend received EINTR, sigev_notify=%s, not ok\n",
 926                                 __FILE__, __LINE__,
 927                                 (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
 928                                  aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
 929                                  aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
 930                                  "unknown") );
 931                         return -errno;
 932                 }
 933         }
 934         else if ( ret ) {
 935             sprintf(Errormsg, "%s/%d aio_suspend(fildes=%d, aioary, 1, NULL) failed, errno:%d %s",
 936                     __FILE__, __LINE__,
 937                 fd, errno, strerror(errno));
 938             return -errno;
 939         }
 940     } else if ( method & LIO_WAIT_ACTIVE ) {
 941         if ( Debug_level > 2 )
 942             printf("DEBUG %s/%d: wait method : active\n", __FILE__, __LINE__);
 943
 944         /* loop while aio_error() returns EINPROGRESS */
 945         cnt=0;
 946         while(1){
 947                 ret = aio_error( aiocbp );
 948                 if( (ret == 0) || (ret != EINPROGRESS) ){
 949                         break;
 950                 }
 951                 ++cnt;
 952         }
 953
 954         if ( Debug_level > 5 && cnt && (cnt % 50) == 0 )
 955                 printf("DEBUG %s/%d: wait active cnt = %d\n",
 956                     __FILE__, __LINE__, cnt);
 957
 958     } else if ( method & LIO_WAIT_SIGPAUSE ) {
 959         if ( Debug_level > 2 )
 960             printf("DEBUG %s/%d: wait method : sigpause\n", __FILE__, __LINE__);
 961         pause();
 962
 963     } else if ( method & LIO_WAIT_SIGACTIVE ) {
 964         if ( Debug_level > 2 )
 965             printf("DEBUG %s/%d: wait method : sigactive\n", __FILE__, __LINE__);
 966         if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
 967                 sigrelse( aiocbp->aio_sigevent.sigev_signo );
 968         else {
 969                 printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n", __FILE__, __LINE__ );
 970                 return -1;
 971         }
 972         /* loop waiting for signal */
 973         while ( Received_signal == Rec_signal ){
 974                 sigrelse( aiocbp->aio_sigevent.sigev_signo );
 975         }
 976
 977     } else if ( method & LIO_WAIT_NONE ) {
 978         if ( Debug_level > 2 )
 979             printf("DEBUG %s/%d: wait method : none\n", __FILE__, __LINE__);
 980         /* It's broken because the aiocb/iosw is an automatic variable in
 981          * lio_{read,write}_buffer, so when the function returns and the
 982          * I/O completes there will be nowhere to write the I/O status.
 983          * It doesn't cause a problem on unicos--probably because of some
 984          * compiler quirk, or an accident.  It causes POSIX async I/O
 985          * to core dump some threads.   spr/pv 705909.  6/27/97 roehrich
 986          */
 987         sprintf(Errormsg, "%s/%d LIO_WAIT_NONE was selected (this is broken)\n",
 988                 __FILE__, __LINE__ );
 989         return -1;
 990     }
 991     else {
 992         if( Debug_level > 2 )
 993             printf("DEBUG %s/%d: no wait method was chosen\n", __FILE__, __LINE__ );
 994         return -1;
 995     }
 996
 997     return 0;
 998
 999 } /* end of lio_wait4asyncio */
1000
1001 #endif /* ifndef linux */
1002
1003 #if UNIT_TEST
1004 /***********************************************************************
1005  * The following code is provided as unit test.
1006  * Just define add "-DUNIT_TEST=1" to the cc line.
1007  *
1008  * (rrl 04/96)
1009  ***********************************************************************/
1010 struct unit_info_t {
1011     int method;
1012     int sig;
1013     char *str;
1014 }  Unit_info[] = {
1015     { LIO_IO_SYNC, 0, "sync io" },
1016     { LIO_IO_SYNCV, 0, "sync readv/writev" },
1017     { LIO_IO_SYNCP, 0, "sync pread/pwrite" },
1018     { LIO_IO_ASYNC, 0, "async io, def wait" },
1019     { LIO_IO_SLISTIO,     0, "sync listio" },
1020     { LIO_IO_ALISTIO,     0, "async listio, def wait" },
1021     { LIO_IO_ASYNC|LIO_WAIT_ACTIVE,     0, "async active" },
1022     { LIO_IO_ASYNC|LIO_WAIT_RECALL,     0, "async recall/suspend" },
1023     { LIO_IO_ASYNC|LIO_WAIT_SIGPAUSE,   SIGUSR1, "async sigpause" },
1024     { LIO_IO_ASYNC|LIO_WAIT_SIGACTIVE,  SIGUSR1, "async sigactive" },
1025     { LIO_IO_ALISTIO|LIO_WAIT_ACTIVE,     0, "async listio active" },
1026     { LIO_IO_ALISTIO|LIO_WAIT_RECALL,     0, "async listio recall" },
1027     { LIO_IO_ALISTIO|LIO_WAIT_SIGACTIVE,  SIGUSR1, "async listio sigactive" },
1028     { LIO_IO_ALISTIO|LIO_WAIT_SIGPAUSE,  SIGUSR1, "async listio sigpause" },
1029     { LIO_IO_ASYNC,     SIGUSR2, "async io, def wait, sigusr2" },
1030     { LIO_IO_ALISTIO,   SIGUSR2, "async listio, def wait, sigusr2" },
1031 };
1032
1033 int
1034 main(argc, argv)
1035 int argc;
1036 char **argv;
1037 {
1038     extern char *optarg;
1039     extern int optind;
1040
1041     int fd;
1042     char *err;
1043     char buffer[4096];
1044     int size=4096;
1045     int ret;
1046     int ind;
1047     int iter=3;
1048     int method;
1049     int exit_status = 0;
1050     int c;
1051     int i;
1052     char *symbols = NULL;
1053     int die_on_err = 0;
1054
1055     while( (c = getopt(argc,argv,"s:di:")) != -1 ){
1056         switch(c){
1057         case 's': symbols = optarg; break;
1058         case 'd': ++die_on_err; break;
1059         case 'i': iter = atoi(optarg); break;
1060         }
1061     }
1062
1063     if ((fd=open("unit_test_file", O_CREAT|O_RDWR|O_TRUNC, 0777)) == -1 ) {
1064         perror("open(unit_test_file, O_CREAT|O_RDWR|O_TRUNC, 0777) failed");
1065         exit(1);
1066     }
1067
1068     Debug_level=9;
1069
1070     if ( symbols != NULL ) {
1071         if ( (method=lio_parse_io_arg2(symbols,  &err)) == -1 ){
1072             printf("lio_parse_io_arg2(%s, &err) failed, bad token starting at %s\n",
1073             symbols, err);
1074             if( die_on_err )
1075                 exit(1);
1076         }
1077         else
1078             printf("lio_parse_io_arg2(%s, &err) returned %#o\n", symbols, method);
1079
1080         exit_status = 0;
1081         for(ind=0; ind < iter; ind++ ) {
1082           memset( buffer, 'A', 4096 );
1083           if( lseek(fd, 0, 0) == -1 ){
1084                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1085                        __LINE__, errno );
1086                 ++exit_status;
1087           }
1088           if ((ret=lio_write_buffer(fd, method, buffer,
1089                         size, SIGUSR1, &err, 0)) != size ) {
1090             printf("lio_write_buffer returned -1, err = %s\n", err);
1091           } else
1092             printf("lio_write_buffer returned %d\n", ret);
1093
1094           memset( buffer, 'B', 4096 );
1095           if( lseek(fd, 0, 0) == -1 ){
1096                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1097                        __LINE__, errno );
1098                 ++exit_status;
1099           }
1100           if ((ret=lio_read_buffer(fd, method, buffer,
1101                         size, SIGUSR2, &err, 0)) != size ) {
1102             printf("lio_read_buffer returned -1, err = %s\n", err);
1103           } else
1104             printf("lio_read_buffer returned %d\n", ret);
1105
1106           for( i = 0; i < 4096; ++i ){
1107                 if( buffer[i] != 'A' ){
1108                         printf("  buffer[%d] = %d\n", i, buffer[i] );
1109                         ++exit_status;
1110                         break;
1111                 }
1112           }
1113
1114           if( exit_status )
1115                 exit(exit_status);
1116
1117         }
1118
1119         unlink("unit_test_file");
1120         exit(0);
1121     }
1122
1123     for(ind=0; ind < sizeof(Unit_info)/sizeof(struct unit_info_t); ind++ ) {
1124
1125         printf("\n********* write %s ***************\n", Unit_info[ind].str);
1126         if( lseek(fd, 0, 0) == -1 ){
1127                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1128                        __LINE__, errno );
1129                 ++exit_status;
1130         }
1131
1132         memset( buffer, 'A', 4096 );
1133         if ((ret=lio_write_buffer(fd, Unit_info[ind].method, buffer,
1134                         size, Unit_info[ind].sig, &err, 0)) != size ) {
1135             printf(">>>>> lio_write_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n   err = %s\n",
1136                    Unit_info[ind].method, size, Unit_info[ind].sig, err);
1137             ++exit_status;
1138             if( die_on_err )
1139                 exit(exit_status);
1140         } else{
1141             printf("lio_write_buffer returned %d\n", ret);
1142         }
1143
1144         printf("\n********* read %s ***************\n", Unit_info[ind].str);
1145         if( lseek(fd, 0, 0) == -1 ){
1146                 printf("lseek(fd,0,0), %d, failed, errno %d\n",
1147                        __LINE__, errno );
1148                 ++exit_status;
1149         }
1150         memset( buffer, 'B', 4096 );
1151         if ((ret=lio_read_buffer(fd, Unit_info[ind].method, buffer,
1152                         size, Unit_info[ind].sig, &err, 0)) != size ) {
1153             printf(">>>>> lio_read_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n   err = %s\n",
1154                    Unit_info[ind].method, size, Unit_info[ind].sig, err);
1155             ++exit_status;
1156             if( die_on_err )
1157                 exit(exit_status);
1158         } else {
1159             printf("lio_read_buffer returned %d\n", ret);
1160         }
1161
1162           for( i = 0; i < 4096; ++i ){
1163                 if( buffer[i] != 'A' ){
1164                         printf("  buffer[%d] = %d\n", i, buffer[i] );
1165                         ++exit_status;
1166                         if( die_on_err )
1167                                 exit(exit_status);
1168                         break;
1169                 }
1170           }
1171
1172         fflush(stdout);
1173         fflush(stderr);
1174         sleep(1);
1175
1176     }
1177
1178     unlink("unit_test_file");
1179
1180     exit(exit_status);
1181 }
1182 #endif