aio_results_np(3) [osf1 man page]

aio_results_np(3)					     Library Functions Manual						 aio_results_np(3)

NAME

       aio_results_np - Returns results for completed asynchronous I/O operations

LIBRARY

       Asynchronous I/O Library (libaio, libaio_raw)

SYNOPSIS

       #include <aio.h>

       typedef struct aio_completion_data {
	       struct aiocb *aio_aiocb;
	       ssize_t aio_result;
	       int aio_error; } aio_completion_t;

       int aio_results_np(
	       aio_completion_t list[],
	       int nent,
	       const struct timespec *timeout,
	       int howmany);

PARAMETERS

       list	   An array of pointers to asynchronous I/O completion data structures.

       nent	   The	number	of  elements  in  the array. This number specifies the number of completed asynchronous I/O operations that can be
		   reported on.   If nent is 0 (zero), the function simply returns the number of aio completions not yet reported on.

       timeout	   A pointer to a timespec structure.  If timeout is NULL, the argument is ignored. If howmany aio operations  are  not  completed
		   within the timeout value, the function fails.

       howmany	   The number of aio operations that must be complete before the the call returns.

DESCRIPTION

       The  aio_results_np function suspends the calling process until at least howmany asynchronous I/O operations have completed, until a signal
       interrupts the function, or until a timeout interval, if specified, has passed.	If at the time of the call howmany asynchronous I/O opera-
       tions are completed, the call returns the requested results without suspending the calling process.

       The  list  argument is an array of pointers to aio_completion_t data structures.  The nent argument indicates the number of elements in the
       array.  On return from a successful call, the function return value specifies the number of valid entries returned in the array.  For  each
       valid  entry,  three  pieces  of  information  are  returned:  The  aio_aiocb field contains a pointer to a completed aiocb structure.  The
       aio_result field contains the return value of the operation; this value is equivalent to the  result  of  a  call  to  aio_return  for  the
       aio_aiocb  field.   The	aio_error  field  contains  the  errno value of the operation; this value is equivalent to the result of a call to
       aio_error for the aio_aiocb field.

       Each valid completion structure represents a completed aio operation.  The function performs the equivalent of an aio_return on each  aiocb
       on which it reports.  In other words, the aiocb pointers returned are ready for immediate reuse by the application.

       If  nent is 0 (zero), the function immediately returns the number of aio completions not yet reported on.  This can be used to quickly poll
       for completion.

RETURN VALUES

       If the function returns successfully, the number of completed aio operations reported on is returned.  That is, the  return  value  is  the
       number  of  valid entries in in the array.  If the value returned is the same as the nent argument, more aio operations may be complete and
       can be reported on by another call to aio_results_np.

       On an unsuccessful call, a value of -1 is returned and errno is set to indicate that an error occurred.

ERRORS

       The aio_results_np function fails under the following conditions:

       [EINTR]	      A signal interrupted the function.

       [EINVAL]       An invalid time value was specified in timeout.

       [EINVAL]       The nent parameter is negative.

       [EINVAL]       The list paramenter is null.

       [EINVAL]       The howmany parameter is greater than the nent parameter.

RELATED INFORMATION

       Functions: aio_group_completion_np(3), aio_read(3), aio_suspend(3), aio_write(3), lio_listio(3)

       Guide to Realtime Programming delim off

																 aio_results_np(3)

aio_waitn(3RT)						    Realtime Library Functions						    aio_waitn(3RT)

NAME

       aio_waitn - wait for completion of asynchronous I/O operations

SYNOPSIS

       cc [ flag... ] file... -lrt [ library... ]
       #include <aio.h>

       int aio_waitn(struct aiocb *list[], uint_t nent, uint_t *nwait, const struct timespec *timeout);

DESCRIPTION

       The  aio_waitn() function suspends the calling thread until at least the number of requests specified by nwait have completed, until a sig-
       nal interrupts the function, or if timeout is not NULL, until the time interval specified by timeout has passed.

       To effect a poll, the timeout argument should be non-zero, pointing to a zero-valued timespec structure.

       The list argument is an array of uninitialized I/O completion block pointers to be filled in by the system before aio_waitn() returns.  The
       nent argument indicates the maximum number of elements that can be placed in list[].

       The nwait argument points to the minimum number of requests aio_waitn() should wait for. Upon returning, the content of nwait is set to the
       actual number of requests in the aiocb list, which can be greater than the initial value  specified  in	nwait.	The  aio_waitn()  function
       attempts  to  return  as many requests as possible, up to the number of outstanding asynchronous I/Os but less than or equal to the maximum
       specified by the nent argument.	As soon as the number of outstanding asynchronous I/O requests becomes 0,  aio_waitn()	returns  with  the
       current list of completed requests.

       The  aiocb  structures  returned  will  have  been  used  in  initiating  an  asynchronous  I/O request from any thread in the process with
       aio_read(3RT), aio_write(3RT), or lio_listio(3RT).

       If the time interval expires before the expected number of I/O operations specified by nwait are completed, aio_waitn() returns the  number
       of completed requests and the content of the nwait pointer is updated with that number.

       If aio_waitn() is interrupted by a signal, nwait is set to the number of completed requests.

       The  application  can  determine  the  status  of  the  completed asynchronous I/O by checking the associated error and return status using
       aio_error(3RT) and aio_return(3RT), respectively.

RETURN VALUES

       Upon successful completion, aio_waitn() returns 0. Otherwise, it returns -1 and sets errno to indicate the error.

ERRORS

       The aio_waitn() function will fail if:

       EAGAIN	       There are no outstanding asynchronous I/O requests.

       EFAULT	       The list[], nwait, or timeout argument points to an address outside the address space of the process. The errno variable is
		       set to EFAULT only if this condition is detected by the application process.

       EINTR	       The execution of aio_waitn() was interrupted by a signal.

       EINVAL	       The timeout element tv_sec or tv_nsec is < 0, nent is set to 0, or nwait is either set to 0 or is > nent.

       ENOMEM	       There is currently not enough available memory. The application can try again later.

       ETIME	       The time interval expired before nwait outstanding requests have completed.

USAGE

       The aio_waitn() function has a transitional interface for 64-bit file offsets.  See lf64(5).

ATTRIBUTES

       See attributes(5) for descriptions of the following attributes:

       +-----------------------------+-----------------------------+
       |      ATTRIBUTE TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Stable			   |
       +-----------------------------+-----------------------------+
       |MT-Level		     |Safe			   |
       +-----------------------------+-----------------------------+

SEE ALSO

       aio.h(3HEAD), aio_error(3RT), aio_read(3RT), aio_write(3RT), lio_listio(3RT), aio_return(3RT), attributes(5), lf64(5)

SunOS 5.10							    12 Nov 2004 						    aio_waitn(3RT)