blob: f7259734af97c753fc6f2c57301af0f26b733795 [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2000 Silicon Graphics, Inc.
* All Rights Reserved.
*/
/*
*
* Lib i/o
*
* This file contains several functions to doing reads and writes.
* It was written so that a single function could be called in a test
* program and only a io type field value would have to change to
* do different types of io. There is even a couple of functions that
* will allow you to parse a string to determine the iotype.
*
* This file contains functions for writing/reading to/from open files
* Prototypes:
*
* Functions declared in this module - see individual function code for
* usage comments:
*
* int stride_bounds(int offset, int stride, int nstrides,
* int bytes_per_stride, int *min, int *max);
* int lio_write_buffer(int fd, int method, char *buffer, int size,
* char **errmsg, long wrd);
* int lio_read_buffer(int fd, int method, char *buffer, int size,
* char **errmsg, long wrd);
* int lio_parse_io_arg1(char *string)
* void lio_help1(char *prefix);
*
* int lio_parse_io_arg2(char *string, char **badtoken)
* void lio_help2(char *prefix);
*
* int lio_set_debug(int level);
*
* char Lio_SysCall[];
* struct lio_info_type Lio_info1[];
* struct lio_info_type Lio_info2[];
*
* Author : Richard Logan
*
*/
#include <stdio.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/param.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/file.h>
#include <signal.h>
#include <sys/uio.h> /* readv(2)/writev(2) */
#include <string.h>
#include <strings.h>
#include <stdlib.h> /* atoi, abs */
#include "tlibio.h" /* defines LIO* marcos */
#ifndef PATH_MAX
#define PATH_MAX MAXPATHLEN
#endif
#if 0 /* disabled until it's needed -- roehrich 6/11/97 */
#define BUG1_workaround 1 /* Work around a condition where aio_return gives
* a value of zero but there is no errno followup
* and the read/write operation actually did its
* job. spr/pv 705244
*/
#endif
#ifndef linux
static void lio_async_signal_handler();
#endif
/*
* Define the structure as used in lio_parse_arg1 and lio_help1
*/
struct lio_info_type Lio_info1[] = {
{ "s", LIO_IO_SYNC, "sync i/o" },
{ "p", LIO_IO_ASYNC|LIO_WAIT_SIGACTIVE, "async i/o using a loop to wait for a signal" },
{ "b", LIO_IO_ASYNC|LIO_WAIT_SIGPAUSE, "async i/o using pause" },
{ "a", LIO_IO_ASYNC|LIO_WAIT_RECALL, "async i/o using recall/aio_suspend" },
{ "r",
LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
{ "R",
LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
{ "l", LIO_IO_SLISTIO|LIO_WAIT_RECALL, "single stride sync listio" },
{ "L", LIO_IO_ALISTIO|LIO_WAIT_RECALL, "single stride async listio using recall" },
{ "X", LIO_IO_ALISTIO|LIO_WAIT_SIGPAUSE, "single stride async listio using pause" },
{ "v", LIO_IO_SYNCV, "single buffer sync readv/writev" },
{ "P", LIO_IO_SYNCP, "sync pread/pwrite" },
};
/*
* Define the structure used by lio_parse_arg2 and lio_help2
*/
struct lio_info_type Lio_info2[] = {
{ "sync", LIO_IO_SYNC, "sync i/o (read/write)"},
{ "async", LIO_IO_ASYNC, "async i/o (reada/writea/aio_read/aio_write)" },
{ "slistio", LIO_IO_SLISTIO, "single stride sync listio" },
{ "alistio", LIO_IO_ALISTIO, "single stride async listio" },
{ "syncv", LIO_IO_SYNCV, "single buffer sync readv/writev"},
{ "syncp", LIO_IO_SYNCP, "pread/pwrite"},
{ "active", LIO_WAIT_ACTIVE, "spin on status/control values" },
{ "recall", LIO_WAIT_RECALL, "use recall(2)/aio_suspend(3) to wait for i/o to complete" },
{ "sigactive", LIO_WAIT_SIGACTIVE, "spin waiting for signal" },
{ "sigpause", LIO_WAIT_SIGPAUSE, "call pause(2) to wait for signal" },
/* nowait is a touchy thing, it's an accident that this implementation worked at all. 6/27/97 roehrich */
/* { "nowait", LIO_WAIT_NONE, "do not wait for async io to complete" },*/
{ "random", LIO_RANDOM, "set random bit" },
{ "randomall",
LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES,
"all random i/o types and wait methods (except nowait)" },
};
char Lio_SysCall[PATH_MAX]; /* string containing last i/o system call */
static volatile int Received_signal = 0; /* number of signals received */
static volatile int Rec_signal;
static char Errormsg[500];
static int Debug_level = 0;
/***********************************************************************
* stride_bounds()
*
* Determine the bounds of a strided request, normalized to offset. Returns
* the number of bytes needed to satisfy the request, and optionally sets
* *min and *max to the mininum and maximum bytes referenced, normalized
* around offset.
*
* Returns -1 on error - the only possible error conditions are illegal values
* for nstrides and/or bytes_per_stride - both parameters must be >= 0.
*
* (maule, 11/16/95)
***********************************************************************/
int
stride_bounds(offset, stride, nstrides, bytes_per_stride, min, max)
int offset;
int stride;
int nstrides;
int bytes_per_stride;
int *min;
int *max;
{
int nbytes, min_byte, max_byte;
/*
* sanity checks ...
*/
if (nstrides < 0 || bytes_per_stride < 0) {
return -1;
}
if (stride == 0) {
stride = bytes_per_stride;
}
/*
* Determine the # of bytes needed to satisfy the request. This
* value, along with the offset argument, determines the min and max
* bytes referenced.
*/
nbytes = abs(stride) * (nstrides-1) + bytes_per_stride;
if (stride < 0) {
max_byte = offset + bytes_per_stride - 1;
min_byte = max_byte - nbytes + 1;
} else {
min_byte = offset;
max_byte = min_byte + nbytes - 1;
}
if (min != NULL) {
*min = min_byte;
}
if (max != NULL) {
*max = max_byte;
}
return nbytes;
}
/***********************************************************************
* This function will allow someone to set the debug level.
***********************************************************************/
int
lio_set_debug(int level)
{
int old;
old = Debug_level;
Debug_level = level;
return old;
}
/***********************************************************************
* This function will parse a string and return desired io-method.
* Only the first character of the string is used.
*
* This function does not provide for meaningful option arguments,
* but it supports current growfiles/btlk interface.
*
* (rrl 04/96)
***********************************************************************/
int
lio_parse_io_arg1(char *string)
{
int ind;
int found=0;
int mask=0;
/*
* Determine if token is a valid string.
*/
for(ind=0; ind<sizeof(Lio_info1)/sizeof(struct lio_info_type); ind++) {
if ( strcmp(string, Lio_info1[ind].token) == 0 ) {
mask |= Lio_info1[ind].bits;
found = 1;
break;
}
}
if ( found == 0 ) {
return -1;
}
return mask;
}
/***********************************************************************
* This function will print a help message describing the characters
* that can be parsed by lio_parse_io_arg1().
* They will be printed one per line.
* (rrl 04/96)
***********************************************************************/
void
lio_help1(char *prefix)
{
int ind;
for(ind=0; ind<sizeof(Lio_info1)/sizeof(struct lio_info_type); ind++) {
printf("%s %s : %s\n", prefix,
Lio_info1[ind].token, Lio_info1[ind].desc);
}
return;
}
/***********************************************************************
* This function will parse a string and return the desired io-method.
* This function will take a comma separated list of io type and wait
* method tokens as defined in Lio_info2[]. If a token does not match
* any of the tokens in Lio_info2[], it will be coverted to a number.
* If it was a number, those bits are also set.
*
* (rrl 04/96)
***********************************************************************/
int
lio_parse_io_arg2(char *string, char **badtoken)
{
char *token = string;
char *cc = token;
char savecc;
int found;
int mask=0;
int tmp;
int ind;
char chr;
if ( token == NULL )
return -1;
for (;;) {
for (; ((*cc != ',') && (*cc != '\0')); cc++);
savecc = *cc;
*cc = '\0';
found = 0;
/*
* Determine if token is a valid string or number and if
* so, add the bits to the mask.
*/
for(ind=0; ind<sizeof(Lio_info2)/sizeof(struct lio_info_type); ind++) {
if ( strcmp(token, Lio_info2[ind].token) == 0 ) {
mask |= Lio_info2[ind].bits;
found = 1;
break;
}
}
/*
* If token does not match one of the defined tokens, determine
* if it is a number, if so, add the bits.
*/
if ( !found ) {
if (sscanf(token, "%i%c", &tmp, &chr) == 1 ) {
mask |= tmp;
found=1;
}
}
*cc = savecc;
if (!found) { /* token is not valid */
if ( badtoken != NULL)
*badtoken = token;
return(-1);
}
if (savecc == '\0')
break;
token = ++cc;
}
return mask;
}
/***********************************************************************
* This function will print a help message describing the tokens
* that can be parsed by lio_parse_io_arg2().
* It will print them one per line.
*
* (rrl 04/96)
***********************************************************************/
void
lio_help2(char *prefix)
{
int ind;
for(ind=0; ind<sizeof(Lio_info2)/sizeof(struct lio_info_type); ind++) {
printf("%s %s : %s\n", prefix,
Lio_info2[ind].token, Lio_info2[ind].desc);
}
return;
}
#ifndef linux
/***********************************************************************
* This is an internal signal handler.
* If the handler is called, it will increment the Received_signal
* global variable.
***********************************************************************/
static void
lio_async_signal_handler(int sig)
{
if ( Debug_level )
printf("DEBUG %s/%d: received signal %d, a signal caught %d times\n",
__FILE__, __LINE__, sig, Received_signal+1);
Received_signal++;
return;
}
#endif
/***********************************************************************
* lio_random_methods
* This function will randomly choose an io type and wait method
* from set of io types and wait methods. Since this information
* is stored in a bitmask, it randomly chooses an io type from
* the io type bits specified and does the same for wait methods.
*
* Return Value
* This function will return a value with all non choosen io type
* and wait method bits cleared. The LIO_RANDOM bit is also
* cleared. All other bits are left unchanged.
*
* (rrl 04/96)
***********************************************************************/
int
lio_random_methods(long curr_mask)
{
int mask=0;
long random_bit(long);
/* remove random select, io type, and wait method bits from curr_mask */
mask = curr_mask & (~(LIO_IO_TYPES | LIO_WAIT_TYPES | LIO_RANDOM));
/* randomly select io type from specified io types */
mask = mask | random_bit(curr_mask & LIO_IO_TYPES);
/* randomly select wait methods from specified wait methods */
mask = mask | random_bit(curr_mask & LIO_WAIT_TYPES);
return mask;
}
/***********************************************************************
* Generic write function
* This function can be used to do a write using write(2), writea(2),
* aio_write(3), writev(2), pwrite(2),
* or single stride listio(2)/lio_listio(3).
* By setting the desired bits in the method
* bitmask, the caller can control the type of write and the wait method
* that will be used. If no io type bits are set, write will be used.
*
* If async io was attempted and no wait method bits are set then the
* wait method is: recall(2) for writea(2) and listio(2); aio_suspend(3) for
* aio_write(3) and lio_listio(3).
*
* If multiple wait methods are specified,
* only one wait method will be used. The order is predetermined.
*
* If the call specifies a signal and one of the two signal wait methods,
* a signal handler for the signal is set. This will reset an already
* set handler for this signal.
*
* If the LIO_RANDOM method bit is set, this function will randomly
* choose a io type and wait method from bits in the method argument.
*
* If an error is encountered, an error message will be generated
* in a internal static buffer. If errmsg is not NULL, it will
* be updated to point to the static buffer, allowing the caller
* to print the error message.
*
* Return Value
* If a system call fails, -errno is returned.
* If LIO_WAIT_NONE bit is set, the return value is the return value
* of the system call.
* If the io did not fail, the amount of data written is returned.
* If the size the system call say was written is different
* then what was asked to be written, errmsg is updated for
* this error condition. The return value is still the amount
* the system call says was written.
*
* (rrl 04/96)
***********************************************************************/
int
lio_write_buffer(fd, method, buffer, size, sig, errmsg, wrd)
int fd; /* open file descriptor */
int method; /* contains io type and wait method bitmask */
char *buffer; /* pointer to buffer */
int size; /* the size of the io */
int sig; /* signal to use if async io */
char **errmsg; /* char pointer that will be updated to point to err message */
long wrd; /* to allow future features, use zero for now */
{
int ret = 0; /* syscall return or used to get random method */
#ifndef linux
int omethod = method;
int listio_cmd; /* Holds the listio/lio_listio cmd */
#endif
struct iovec iov; /* iovec for writev(2) */
/*
* If LIO_RANDOM bit specified, get new method randomly.
*/
if ( method & LIO_RANDOM ) {
if( Debug_level > 3 )
printf("DEBUG %s/%d: method mask to choose from: %#o\n", __FILE__, __LINE__, method );
method = lio_random_methods(method);
if ( Debug_level > 2 )
printf("DEBUG %s/%d: random chosen method %#o\n", __FILE__, __LINE__, method);
}
if ( errmsg != NULL )
*errmsg = Errormsg;
Rec_signal=Received_signal; /* get the current number of signals received */
bzero(&iov, sizeof(struct iovec));
iov.iov_base = buffer;
iov.iov_len = size;
/*
* If the LIO_USE_SIGNAL bit is not set, only use the signal
* if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are bit.
* Otherwise there is not necessary a signal handler to trap
* the signal.
*/
if ( sig && !(method & LIO_USE_SIGNAL) &&
! (method & LIO_WAIT_SIGTYPES) ){
sig=0; /* ignore signal parameter */
}
/*
* only setup signal hander if sig was specified and
* a sig wait method was specified.
* Doing this will change the handler for this signal. The
* old signal handler will not be restored.
*** restoring the signal handler could be added ***
*/
/*
* Determine the system call that will be called and produce
* the string of the system call and place it in Lio_SysCall.
* Execute the system call and check for system call failure.
* If sync i/o, return the number of bytes written/read.
*/
if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
/*
* write(2) is used if LIO_IO_SYNC bit is set or not none
* of the LIO_IO_TYPES bits are set (default).
*/
sprintf(Lio_SysCall,
"write(%d, buf, %d)", fd, size);
if ( Debug_level ) {
printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
}
if ((ret = write(fd, buffer, size)) == -1) {
sprintf(Errormsg, "%s/%d write(%d, buf, %d) ret:-1, errno=%d %s",
__FILE__, __LINE__,
fd, size, errno, strerror(errno));
return -errno;
}
if ( ret != size ) {
sprintf(Errormsg,
"%s/%d write(%d, buf, %d) returned=%d",
__FILE__, __LINE__,
fd, size, ret);
}
else if ( Debug_level > 1 )
printf("DEBUG %s/%d: write completed without error (ret %d)\n",
__FILE__, __LINE__, ret);
return ret;
}
else if ( method & LIO_IO_SYNCV ) {
sprintf(Lio_SysCall,
"writev(%d, &iov, 1) nbyte:%d", fd, size);
if ( Debug_level ) {
printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
}
if ((ret = writev(fd, &iov, 1)) == -1) {
sprintf(Errormsg, "%s/%d writev(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
__FILE__, __LINE__,
fd, size, errno, strerror(errno));
return -errno;
}
if ( ret != size ) {
sprintf(Errormsg,
"%s/%d writev(%d, iov, 1) nbyte:%d returned=%d",
__FILE__, __LINE__,
fd, size, ret);
}
else if ( Debug_level > 1 )
printf("DEBUG %s/%d: writev completed without error (ret %d)\n",
__FILE__, __LINE__, ret);
return ret;
} /* LIO_IO_SYNCV */
else {
printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
return -1;
}
/*
* If there was an error waiting for async i/o to complete,
* return the error value (errno) to the caller.
* Note: Errormsg should already have been updated.
*/
if ( ret < 0 ) {
return ret;
}
/*
* If i/o was not waited for (may not have been completed at this time),
* return the size that was requested.
*/
if ( ret == 1 )
return size;
/*
* check that async io was successful.
* Note: if the there was an system call failure, -errno
* was returned and Errormsg should already have been updated.
* If amount i/o was different than size, Errormsg should already
* have been updated but the actual i/o size if returned.
*/
return ret;
} /* end of lio_write_buffer */
/***********************************************************************
* Generic read function
* This function can be used to do a read using read(2), reada(2),
* aio_read(3), readv(2), pread(2),
* or single stride listio(2)/lio_listio(3).
* By setting the desired bits in the method
* bitmask, the caller can control the type of read and the wait method
* that will be used. If no io type bits are set, read will be used.
*
* If async io was attempted and no wait method bits are set then the
* wait method is: recall(2) for reada(2) and listio(2); aio_suspend(3) for
* aio_read(3) and lio_listio(3).
*
* If multiple wait methods are specified,
* only one wait method will be used. The order is predetermined.
*
* If the call specifies a signal and one of the two signal wait methods,
* a signal handler for the signal is set. This will reset an already
* set handler for this signal.
*
* If the LIO_RANDOM method bit is set, this function will randomly
* choose a io type and wait method from bits in the method argument.
*
* If an error is encountered, an error message will be generated
* in a internal static buffer. If errmsg is not NULL, it will
* be updated to point to the static buffer, allowing the caller
* to print the error message.
*
* Return Value
* If a system call fails, -errno is returned.
* If LIO_WAIT_NONE bit is set, the return value is the return value
* of the system call.
* If the io did not fail, the amount of data written is returned.
* If the size the system call say was written is different
* then what was asked to be written, errmsg is updated for
* this error condition. The return value is still the amount
* the system call says was written.
*
* (rrl 04/96)
***********************************************************************/
int
lio_read_buffer(fd, method, buffer, size, sig, errmsg, wrd)
int fd; /* open file descriptor */
int method; /* contains io type and wait method bitmask */
char *buffer; /* pointer to buffer */
int size; /* the size of the io */
int sig; /* signal to use if async io */
char **errmsg; /* char pointer that will be updated to point to err message */
long wrd; /* to allow future features, use zero for now */
{
int ret = 0; /* syscall return or used to get random method */
#ifndef linux
int listio_cmd; /* Holds the listio/lio_listio cmd */
int omethod = method;
#endif
struct iovec iov; /* iovec for readv(2) */
/*
* If LIO_RANDOM bit specified, get new method randomly.
*/
if ( method & LIO_RANDOM ) {
if( Debug_level > 3 )
printf("DEBUG %s/%d: method mask to choose from: %#o\n", __FILE__, __LINE__, method );
method = lio_random_methods(method);
if ( Debug_level > 2 )
printf("DEBUG %s/%d: random chosen method %#o\n", __FILE__, __LINE__, method);
}
if ( errmsg != NULL )
*errmsg = Errormsg;
Rec_signal=Received_signal; /* get the current number of signals received */
bzero(&iov, sizeof(struct iovec));
iov.iov_base = buffer;
iov.iov_len = size;
/*
* If the LIO_USE_SIGNAL bit is not set, only use the signal
* if the LIO_WAIT_SIGPAUSE or the LIO_WAIT_SIGACTIVE bits are set.
* Otherwise there is not necessarily a signal handler to trap
* the signal.
*/
if ( sig && !(method & LIO_USE_SIGNAL) &&
! (method & LIO_WAIT_SIGTYPES) ){
sig=0; /* ignore signal parameter */
}
/*
* only setup signal hander if sig was specified and
* a sig wait method was specified.
* Doing this will change the handler for this signal. The
* old signal handler will not be restored.
*** restoring the signal handler could be added ***
*/
/*
* Determine the system call that will be called and produce
* the string of the system call and place it in Lio_SysCall.
* Execute the system call and check for system call failure.
* If sync i/o, return the number of bytes written/read.
*/
if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
/*
* read(2) is used if LIO_IO_SYNC bit is set or not none
* of the LIO_IO_TYPES bits are set (default).
*/
sprintf(Lio_SysCall,
"read(%d, buf, %d)", fd, size);
if ( Debug_level ) {
printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
}
if ((ret = read(fd, buffer, size)) == -1) {
sprintf(Errormsg, "%s/%d read(%d, buf, %d) ret:-1, errno=%d %s",
__FILE__, __LINE__,
fd, size, errno, strerror(errno));
return -errno;
}
if ( ret != size ) {
sprintf(Errormsg,
"%s/%d read(%d, buf, %d) returned=%d",
__FILE__, __LINE__,
fd, size, ret);
}
else if ( Debug_level > 1 )
printf("DEBUG %s/%d: read completed without error (ret %d)\n",
__FILE__, __LINE__, ret);
return ret;
}
else if ( method & LIO_IO_SYNCV ) {
sprintf(Lio_SysCall,
"readv(%d, &iov, 1) nbyte:%d", fd, size);
if ( Debug_level ) {
printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
}
if ((ret = readv(fd, &iov, 1)) == -1) {
sprintf(Errormsg, "%s/%d readv(%d, iov, 1) nbyte:%d ret:-1, errno=%d %s",
__FILE__, __LINE__,
fd, size, errno, strerror(errno));
return -errno;
}
if ( ret != size ) {
sprintf(Errormsg,
"%s/%d readv(%d, iov, 1) nbyte:%d returned=%d",
__FILE__, __LINE__,
fd, size, ret);
}
else if ( Debug_level > 1 )
printf("DEBUG %s/%d: readv completed without error (ret %d)\n",
__FILE__, __LINE__, ret);
return ret;
} /* LIO_IO_SYNCV */
else {
printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
return -1;
}
/*
* If there was an error waiting for async i/o to complete,
* return the error value (errno) to the caller.
* Note: Errormsg should already have been updated.
*/
if ( ret < 0 ) {
return ret;
}
/*
* If i/o was not waited for (may not have been completed at this time),
* return the size that was requested.
*/
if ( ret == 1 )
return size;
/*
* check that async io was successful.
* Note: if the there was an system call failure, -errno
* was returned and Errormsg should already have been updated.
* If amount i/o was different than size, Errormsg should already
* have been updated but the actual i/o size if returned.
*/
return ret;
} /* end of lio_read_buffer */
#ifndef linux
/***********************************************************************
* This function will check that async io was successful.
* It can also be used to check sync listio since it uses the
* same method.
*
* Return Values
* If status.sw_error is set, -status.sw_error is returned.
* Otherwise sw_count's field value is returned.
*
* (rrl 04/96)
***********************************************************************/
int
lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
{
int ret;
int cnt = 1;
/* The I/O may have been synchronous with signal completion. It doesn't
* make sense, but the combination could be generated. Release the
* completion signal here otherwise it'll hang around and bite us
* later.
*/
if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
sigrelse( aiocbp->aio_sigevent.sigev_signo );
ret = aio_error( aiocbp );
while( ret == EINPROGRESS ){
ret = aio_error( aiocbp );
++cnt;
}
if( cnt > 1 ){
sprintf(Errormsg,
"%s/%d %s, aio_error had to loop on EINPROGRESS, cnt=%d; random method %#o; sigev_notify=%s",
__FILE__, __LINE__, io_type, cnt, method,
(aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
"unknown") );
return -ret;
}
if( ret != 0 ){
sprintf(Errormsg,
"%s/%d %s, aio_error = %d %s; random method %#o",
__FILE__, __LINE__, io_type,
ret, strerror(ret),
method );
return -ret;
}
ret = aio_return( aiocbp );
if( ret != size ){
sprintf(Errormsg,
"%s/%d %s, aio_return not as expected(%d), but actual:%d",
__FILE__, __LINE__, io_type,
size, ret);
#ifdef BUG1_workaround
if( ret == 0 ){
ret = size;
if( Debug_level > 1 ){
printf("WARN %s/%d: %s completed with bug1_workaround (aio_error == 0, aio_return now == %d)\n",
__FILE__, __LINE__, io_type, ret);
}
}
#endif /* BUG1_workaround */
}
else if( Debug_level > 1 ){
printf("DEBUG %s/%d: %s completed without error (aio_error == 0, aio_return == %d)\n",
__FILE__, __LINE__, io_type, ret);
}
return ret;
} /* end of lio_check_asyncio */
/***********************************************************************
*
* This function will wait for async io to complete.
* If multiple wait methods are specified, the order is predetermined
* to LIO_WAIT_RECALL,
* LIO_WAIT_ACTIVE, LIO_WAIT_SIGPAUSE, LIO_WAIT_SIGACTIVE,
* then LIO_WAIT_NONE.
*
* If no wait method was specified the default wait method is: recall(2)
* or aio_suspend(3), as appropriate.
*
* Return Values
* <0: errno of failed recall
* 0 : async io was completed
* 1 : async was not waited for, io may not have completed.
*
* (rrl 04/96)
***********************************************************************/
int
lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
{
int cnt;
if ( (method & LIO_WAIT_RECALL)
|| ((method & LIO_WAIT_TYPES) == 0) ){
/*
* If method has LIO_WAIT_RECALL bit set or method does
* not have any wait method bits set (default), use recall/aio_suspend.
*/
if ( Debug_level > 2 )
printf("DEBUG %s/%d: wait method : aio_suspend, sigev_notify=%s\n", __FILE__, __LINE__,
(aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
"unknown") );
aioary[0] = aiocbp;
ret = aio_suspend( aioary, 1, NULL );
if( (ret == -1) && (errno == EINTR) ){
if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ){
if( Debug_level > 2 ){
printf("DEBUG %s/%d: aio_suspend received EINTR, sigev_notify=SIGEV_SIGNAL -- ok\n",
__FILE__, __LINE__ );
}
}
else {
sprintf(Errormsg, "%s/%d aio_suspend received EINTR, sigev_notify=%s, not ok\n",
__FILE__, __LINE__,
(aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
aiocbp->aio_sigevent.sigev_notify == SIGEV_NONE ? "none" :
aiocbp->aio_sigevent.sigev_notify == SIGEV_CALLBACK ? "callback" :
"unknown") );
return -errno;
}
}
else if ( ret ) {
sprintf(Errormsg, "%s/%d aio_suspend(fildes=%d, aioary, 1, NULL) failed, errno:%d %s",
__FILE__, __LINE__,
fd, errno, strerror(errno));
return -errno;
}
} else if ( method & LIO_WAIT_ACTIVE ) {
if ( Debug_level > 2 )
printf("DEBUG %s/%d: wait method : active\n", __FILE__, __LINE__);
/* loop while aio_error() returns EINPROGRESS */
cnt=0;
while(1){
ret = aio_error( aiocbp );
if( (ret == 0) || (ret != EINPROGRESS) ){
break;
}
++cnt;
}
if ( Debug_level > 5 && cnt && (cnt % 50) == 0 )
printf("DEBUG %s/%d: wait active cnt = %d\n",
__FILE__, __LINE__, cnt);
} else if ( method & LIO_WAIT_SIGPAUSE ) {
if ( Debug_level > 2 )
printf("DEBUG %s/%d: wait method : sigpause\n", __FILE__, __LINE__);
pause();
} else if ( method & LIO_WAIT_SIGACTIVE ) {
if ( Debug_level > 2 )
printf("DEBUG %s/%d: wait method : sigactive\n", __FILE__, __LINE__);
if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
sigrelse( aiocbp->aio_sigevent.sigev_signo );
else {
printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n", __FILE__, __LINE__ );
return -1;
}
/* loop waiting for signal */
while ( Received_signal == Rec_signal ){
sigrelse( aiocbp->aio_sigevent.sigev_signo );
}
} else if ( method & LIO_WAIT_NONE ) {
if ( Debug_level > 2 )
printf("DEBUG %s/%d: wait method : none\n", __FILE__, __LINE__);
/* It's broken because the aiocb/iosw is an automatic variable in
* lio_{read,write}_buffer, so when the function returns and the
* I/O completes there will be nowhere to write the I/O status.
* It doesn't cause a problem on unicos--probably because of some
* compiler quirk, or an accident. It causes POSIX async I/O
* to core dump some threads. spr/pv 705909. 6/27/97 roehrich
*/
sprintf(Errormsg, "%s/%d LIO_WAIT_NONE was selected (this is broken)\n",
__FILE__, __LINE__ );
return -1;
}
else {
if( Debug_level > 2 )
printf("DEBUG %s/%d: no wait method was chosen\n", __FILE__, __LINE__ );
return -1;
}
return 0;
} /* end of lio_wait4asyncio */
#endif /* ifndef linux */
#if UNIT_TEST
/***********************************************************************
* The following code is provided as unit test.
* Just define add "-DUNIT_TEST=1" to the cc line.
*
* (rrl 04/96)
***********************************************************************/
struct unit_info_t {
int method;
int sig;
char *str;
} Unit_info[] = {
{ LIO_IO_SYNC, 0, "sync io" },
{ LIO_IO_SYNCV, 0, "sync readv/writev" },
{ LIO_IO_SYNCP, 0, "sync pread/pwrite" },
{ LIO_IO_ASYNC, 0, "async io, def wait" },
{ LIO_IO_SLISTIO, 0, "sync listio" },
{ LIO_IO_ALISTIO, 0, "async listio, def wait" },
{ LIO_IO_ASYNC|LIO_WAIT_ACTIVE, 0, "async active" },
{ LIO_IO_ASYNC|LIO_WAIT_RECALL, 0, "async recall/suspend" },
{ LIO_IO_ASYNC|LIO_WAIT_SIGPAUSE, SIGUSR1, "async sigpause" },
{ LIO_IO_ASYNC|LIO_WAIT_SIGACTIVE, SIGUSR1, "async sigactive" },
{ LIO_IO_ALISTIO|LIO_WAIT_ACTIVE, 0, "async listio active" },
{ LIO_IO_ALISTIO|LIO_WAIT_RECALL, 0, "async listio recall" },
{ LIO_IO_ALISTIO|LIO_WAIT_SIGACTIVE, SIGUSR1, "async listio sigactive" },
{ LIO_IO_ALISTIO|LIO_WAIT_SIGPAUSE, SIGUSR1, "async listio sigpause" },
{ LIO_IO_ASYNC, SIGUSR2, "async io, def wait, sigusr2" },
{ LIO_IO_ALISTIO, SIGUSR2, "async listio, def wait, sigusr2" },
};
int
main(argc, argv)
int argc;
char **argv;
{
extern char *optarg;
extern int optind;
int fd;
char *err;
char buffer[4096];
int size=4096;
int ret;
int ind;
int iter=3;
int method;
int exit_status = 0;
int c;
int i;
char *symbols = NULL;
int die_on_err = 0;
while( (c = getopt(argc,argv,"s:di:")) != -1 ){
switch(c){
case 's': symbols = optarg; break;
case 'd': ++die_on_err; break;
case 'i': iter = atoi(optarg); break;
}
}
if ((fd=open("unit_test_file", O_CREAT|O_RDWR|O_TRUNC, 0777)) == -1 ) {
perror("open(unit_test_file, O_CREAT|O_RDWR|O_TRUNC, 0777) failed");
exit(1);
}
Debug_level=9;
if ( symbols != NULL ) {
if ( (method=lio_parse_io_arg2(symbols, &err)) == -1 ){
printf("lio_parse_io_arg2(%s, &err) failed, bad token starting at %s\n",
symbols, err);
if( die_on_err )
exit(1);
}
else
printf("lio_parse_io_arg2(%s, &err) returned %#o\n", symbols, method);
exit_status = 0;
for(ind=0; ind < iter; ind++ ) {
memset( buffer, 'A', 4096 );
if( lseek(fd, 0, 0) == -1 ){
printf("lseek(fd,0,0), %d, failed, errno %d\n",
__LINE__, errno );
++exit_status;
}
if ((ret=lio_write_buffer(fd, method, buffer,
size, SIGUSR1, &err, 0)) != size ) {
printf("lio_write_buffer returned -1, err = %s\n", err);
} else
printf("lio_write_buffer returned %d\n", ret);
memset( buffer, 'B', 4096 );
if( lseek(fd, 0, 0) == -1 ){
printf("lseek(fd,0,0), %d, failed, errno %d\n",
__LINE__, errno );
++exit_status;
}
if ((ret=lio_read_buffer(fd, method, buffer,
size, SIGUSR2, &err, 0)) != size ) {
printf("lio_read_buffer returned -1, err = %s\n", err);
} else
printf("lio_read_buffer returned %d\n", ret);
for( i = 0; i < 4096; ++i ){
if( buffer[i] != 'A' ){
printf(" buffer[%d] = %d\n", i, buffer[i] );
++exit_status;
break;
}
}
if( exit_status )
exit(exit_status);
}
unlink("unit_test_file");
exit(0);
}
for(ind=0; ind < sizeof(Unit_info)/sizeof(struct unit_info_t); ind++ ) {
printf("\n********* write %s ***************\n", Unit_info[ind].str);
if( lseek(fd, 0, 0) == -1 ){
printf("lseek(fd,0,0), %d, failed, errno %d\n",
__LINE__, errno );
++exit_status;
}
memset( buffer, 'A', 4096 );
if ((ret=lio_write_buffer(fd, Unit_info[ind].method, buffer,
size, Unit_info[ind].sig, &err, 0)) != size ) {
printf(">>>>> lio_write_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n err = %s\n",
Unit_info[ind].method, size, Unit_info[ind].sig, err);
++exit_status;
if( die_on_err )
exit(exit_status);
} else{
printf("lio_write_buffer returned %d\n", ret);
}
printf("\n********* read %s ***************\n", Unit_info[ind].str);
if( lseek(fd, 0, 0) == -1 ){
printf("lseek(fd,0,0), %d, failed, errno %d\n",
__LINE__, errno );
++exit_status;
}
memset( buffer, 'B', 4096 );
if ((ret=lio_read_buffer(fd, Unit_info[ind].method, buffer,
size, Unit_info[ind].sig, &err, 0)) != size ) {
printf(">>>>> lio_read_buffer(fd,0%x,buffer,%d,%d,err,0) returned -1,\n err = %s\n",
Unit_info[ind].method, size, Unit_info[ind].sig, err);
++exit_status;
if( die_on_err )
exit(exit_status);
} else {
printf("lio_read_buffer returned %d\n", ret);
}
for( i = 0; i < 4096; ++i ){
if( buffer[i] != 'A' ){
printf(" buffer[%d] = %d\n", i, buffer[i] );
++exit_status;
if( die_on_err )
exit(exit_status);
break;
}
}
fflush(stdout);
fflush(stderr);
sleep(1);
}
unlink("unit_test_file");
exit(exit_status);
}
#endif