


     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



     NAME
	  rt.os/aio/lio_listio - list directed I/O  testset

     DESCRIPTION
	  Tests	the lio_listio() function for conformance to System
	  Interfaces and Headers, Issue	5 Page:	lio_listio().

     TESTS
     Compliance
	  1    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A successful call to lio_listio() when	mode is
		 LIO_WAIT shall	initiate the nent asynchronous I/O
		 requests in list, wait	until all I/O is complete,
		 return	0, and not generate a signal on	completion.

	  2    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A successful call to lio_listio() when	mode is
		 LIO_NOWAIT shall initiate or queue the	nent
		 asynchronous I/O requests in list, and	return 0
		 immediately.

	  3    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	mode is	LIO_NOWAIT and
		 sig->sigev_notify is SIGEV_NONE no asynchronous
		 notification shall be delivered when the all the
		 operations complete.

	  4    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	mode is	LIO_NOWAIT and
		 sig is	NULL no	asynchronous notification shall	be
		 delivered when	the all	the operations complete.

	  5    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	mode is	LIO_NOWAIT and
		 sig->sigev_notify is SIGEV_SIGNAL the signal
		 specified in sig->sigev_signo shall be	generated for
		 the process when the all the operations complete.

	  6    If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:



     Page 1					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



		 On a call to lio_listio() when	mode is	LIO_NOWAIT and
		 sig->sigev_notify is SIGEV_SIGNAL and the SA_SIGINFO
		 flag is set for the signal specified in sig-
		 >sigev_signo, the signal shall	be queued for the
		 process when it is generated and the value specified
		 in sig->sigev_value shall be in the si_value
		 component of the generated signal.

	  7    If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	mode is	LIO_NOWAIT and
		 sig->sigev_notify is SIGEV_THREAD the function	in
		 sig->sigev_notify_function shall be called with the
		 value of sig->sigev_value as a	parameter when all the
		 operations complete, executed in an environment as if
		 it were the start_routine for a newly created thread
		 with thread attributes	specified by sig-
		 >sigev_notify_attributes.

	  8    If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	mode is	LIO_NOWAIT,
		 sig->sigev_notify is SIGEV_THREAD, and	sig-
		 >sigev_notify_attributes is NULL, the function	in
		 sig->sigev_notify_function shall be called with the
		 value of sig->sigev_value as a	parameter when all the
		 operations complete, executed in an environment as if
		 it were the start_routine for a newly created thread
		 with the detachstate attribute	set to
		 PTHREAD_CREATE_DETACHED.

	  9    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall ignore NULL entries in
		 list.

	  10   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall ignore list entries for
		 which the aio_lio_opcode member is LIST_NOP.

	  11   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 The addresses of the aiocb structures passed to
		 lio_listio() in list shall be usable as arguments to



     Page 2					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



		 aio_error() and aio_return() in order to determine
		 the error and return status, respectively, of an
		 operation while it is proceeding.

	  12   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 When list[n].aio_lio_opcode is	LIO_READ a call	to
		 lio_listio() shall initiate or	queue a	request	on
		 behalf	of the calling process to read list[n]-
		 >aio_nbytes from the file associated with list[n]-
		 >aio_fildes into the buffer pointed to	by list[n]-
		 >aio_buf.

	  13   If _POSIX_ASYNCHRONOUS_IO and _POSIX_PRIORITIZED_IO are
	       defined or the implementation supports the lio_listio()
	       function	as described in	System Interfaces and Headers,
	       Issue 5:
		 A read	request	generated by a call to lio_listio()
		 from a	process	whose scheduling policy	is SCHED_FIFO
		 or SCHED_RR shall be queued in	priority order at a
		 priority equal	to the scheduling priority of the
		 process minus list[n]->aio_reqprio for	values of
		 list[n]->aio_reqprio which lower the operation
		 priority, in the range	0 to {AIO_PRIO_DELTA_MAX}.

	  14   If _POSIX_ASYNCHRONOUS_IO and _POSIX_PRIORITIZED_IO are
	       defined or the implementation supports the lio_listio()
	       function	as described in	System Interfaces and Headers,
	       Issue 5,	and the	implementation supports	prioritized
	       I/O on character	special	files:
		 Read requests generated by calls to lio_listio() from
		 processes whose scheduling policy is SCHED_FIFO or
		 SCHED_RR with the same	priority to a character
		 special file shall be processed by the	underlying
		 device	in FIFO	order.

	  15   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 Unless	list[n]->aio_fildes is associated with a
		 device	which is incapable of seeking a	request
		 generated by a	call to	lio_listio() when list[n]-
		 >aio_lio_opcode is LIO_READ shall take	place at the
		 absolute position in the file given by	list[n]-
		 >aio_offset.

	  16   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ and list[n]-



     Page 3					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



		 >aio_sigevent.sigev_notify is SIGEV_NONE no
		 asynchronous notification shall be delivered when the
		 operation completes.

	  17   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ and list[n]-
		 >aio_sigevent.sigev_notify is SIGEV_SIGNAL the	signal
		 specified in list[n]->aio_sigevent.sigev_signo	shall
		 be generated for the process when the operation
		 completes.

	  18   If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ and list[n]-
		 >aio_sigevent.sigev_notify is SIGEV_SIGNAL and	the
		 SA_SIGINFO flag is set	for the	signal specified in
		 list[n]->aio_sigevent.sigev_signo, the	signal shall
		 be queued for the process when	it is generated	and
		 the value specified in	list[n]-
		 >aio_sigevent.sigev_value shall be in the si_value
		 component of the generated signal.

	  19   If _POSIX_ASYNCHRONOUS_IO, and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ and list[n]-
		 >aio_sigevent.sigev_notify is SIGEV_THREAD the
		 function in list[n]-
		 >aio_sigevent.sigev_notify_function shall be called
		 with the value	of list[n]->aio_sigevent.sigev_value
		 as a parameter	when the operation completes, executed
		 in an environment as if it were the start_routine for
		 a newly created thread	with thread attributes
		 specified by list[n]-
		 >aio_sigevent.sigev_notify_attributes.

	  20   If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ, list[n]-
		 >aio_sigevent.sigev_notify is SIGEV_THREAD, and
		 list[n]->aio_sigevent.sigev_notify_attributes is



     Page 4					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



		 NULL, the function in list[n]-
		 >aio_sigevent.sigev_notify_function shall be called
		 with the value	of list[n]->aio_sigevent.sigev_value
		 as a parameter	when the operation completes, executed
		 in an environment as if it were the start_routine for
		 a newly created thread	with the detachstate attribute
		 set to	PTHREAD_CREATE_DETACHED.

	  21   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 When list[n].aio_lio_opcode is	LIO_WRITE a call to
		 lio_listio() shall initiate or	queue a	request	on
		 behalf	of the calling process to write	list[n]-
		 >aio_nbytes from the file associated with list[n]-
		 >aio_fildes from the buffer pointed to	by list[n]-
		 >aio_buf.

	  22   If _POSIX_ASYNCHRONOUS_IO and _POSIX_PRIORITIZED_IO are
	       defined or the implementation supports the lio_listio()
	       function	as described in	System Interfaces and Headers,
	       Issue 5:
		 A write request generated by a	call to	lio_listio()
		 from a	process	whose scheduling policy	is SCHED_FIFO
		 or SCHED_RR shall be queued in	priority order at a
		 priority equal	to the scheduling priority of the
		 process minus list[n]->aio_reqprio for	values of
		 list[n]->aio_reqprio which lower the operation
		 priority, in the range	0 to {AIO_PRIO_DELTA_MAX}.

	  23   If _POSIX_ASYNCHRONOUS_IO and _POSIX_PRIORITIZED_IO are
	       defined or the implementation supports the lio_listio()
	       function	as described in	System Interfaces and Headers,
	       Issue 5,	and the	implementation supports	prioritized
	       I/O on character	special	files:
		 Write requests	generated by calls to lio_listio()
		 from processes	whose scheduling policy	is SCHED_FIFO
		 or SCHED_RR with the same priority to a character
		 special file shall be processed by the	underlying
		 device	in FIFO	order.

	  24   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 Unless	the O_APPEND flag is set for list[n]-
		 >aio_fildes or	that file is associated	with a device
		 which is incapable of seeking a request generated by
		 a call	to lio_listio()	when list[n].aio_lio_opcode is
		 LIO_WRITE shall take place at the absolute position
		 in the	file given by list[n]->aio_offset.

	  25   If _POSIX_ASYNCHRONOUS_IO is defined or the



     Page 5					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 If the	O_APPEND flag is set for list[n]->aio_fildes
		 write requests	generated by calls to lio_listio()
		 shall append to the file.

	  26   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and list[n]->aio_sigevent.sigev_notify
		 is SIGEV_NONE no asynchronous notification shall be
		 delivered when	the operation completes.

	  27   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and list[n]->aio_sigevent.sigev_notify
		 is SIGEV_SIGNAL the signal specified in list[n]-
		 >aio_sigevent.sigev_signo shall be generated for the
		 process when the operation completes.

	  28   If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and list[n]->aio_sigevent.sigev_notify
		 is SIGEV_SIGNAL and the SA_SIGINFO flag is set	for
		 the signal specified in list[n]-
		 >aio_sigevent.sigev_signo, the	signal shall be	queued
		 for the process when it is generated and the value
		 specified in list[n]->aio_sigevent.sigev_value	shall
		 be in the si_value component of the generated signal.

	  29   If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and list[n]->aio_sigevent.sigev_notify
		 is SIGEV_THREAD the function in list[n]-
		 >aio_sigevent.sigev_notify_function shall be called
		 with the value	of list[n]->aio_sigevent.sigev_value
		 as a parameter	when the operation completes, executed
		 in an environment as if it were the start_routine for
		 a newly created thread	with thread attributes
		 specified by list[n]-
		 >aio_sigevent.sigev_notify_attributes.

	  30   If _POSIX_ASYNCHRONOUS_IO and _POSIX_REALTIME_SIGNALS



     Page 6					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE, list[n]->aio_sigevent.sigev_notify is
		 SIGEV_THREAD, and list[n]-
		 >aio_sigevent.sigev_notify_attributes is NULL,	the
		 function in list[n]-
		 >aio_sigevent.sigev_notify_function shall be called
		 with the value	of list[n]->aio_sigevent.sigev_value
		 as a parameter	when the operation completes, executed
		 in an environment as if it were the start_routine for
		 a newly created thread	with the detachstate attribute
		 set to	PTHREAD_CREATE_DETACHED.

     Deviance
	  31   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall return -1	and set	errno
		 to EAGAIN when	the number of entries indicated	by
		 nent would cause the systemwide limit AIO_MAX to be
		 exceeded.

	  32   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall return -1	and set	errno
		 to EINVAL when	mode is	not a proper value.

	  33   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall return -1	and set	errno
		 to EINVAL when	the value of nent is greater than
		 AIO_LISTIO_MAX.

	  34   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	when mode is LIO_WAIT shall
		 return	-1 and set errno to EINTR when the operation
		 is interrupted	by a signal.

	  35   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall return -1	and set	errno
		 to EIO	when one of more of the	individual I/O
		 operations fail.

	  36   If _POSIX_ASYNCHRONOUS_IO is defined or the



     Page 7					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ and list[n]->aio_fildes
		 is not	a valid	file descriptor	open for reading the
		 return	status of the asynchronous operation shall be
		 set to	-1 and its error status	shall be set to	EBADF.

	  37   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ and the offset implied by
		 list[n]->aio_offset would be invalid the return
		 status	of the asynchronous operation shall be set to
		 -1 and	its error status shall be set to EINVAL.

	  38   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n]-
		 >aio_lio_opcode is LIO_READ and list[n]->aio_reqprio
		 is not	a valid	value the return status	of the
		 asynchronous operation	shall be set to	-1 and its
		 error status shall be set to EINVAL.

	  39   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 When list[n]->aio_lio_opcode is LIO_READ and
		 list[n]->aio_nbytes is	not a valid value the return
		 status	of the asynchronous operation shall be set to
		 -1 and	its error status shall be set to EINVAL.

	  40   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and list[n]->aio_fildes is not a valid
		 file descriptor open for writing the return status of
		 the asynchronous operation shall be set to -1 and its
		 error status shall be set to EBADF.

	  41   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and the offset implied by	list[n]-
		 >aio_offset would be invalid the return status	of the
		 asynchronous operation	shall be set to	-1 and its
		 error status shall be set to EINVAL.




     Page 8					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



	  42   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and list[n]->aio_reqprio is not a	valid
		 value the return status of the	asynchronous operation
		 shall be set to -1 and	its error status shall be set
		 to EINVAL.

	  43   This assertion is not in	use.

	  44   If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	a requested operation
		 is canceled by	a call to aio_cancel() the return
		 status	of the asynchronous operation shall be set to
		 -1 and	its error status shall be set to ECANCELED.

	  45   If _POSIX_ASYNCHRONOUS_IO is not	defined	and the
	       implementation does not support the lio_listio()
	       function	as described in	System Interfaces and Headers,
	       Issue 5:
		 A call	to lio_listio()	shall return -1	and set	errno
		 to ENOSYS.

     Untestable	Aspects
	  1    If _POSIX_ASYNCHRONOUS_IO and _POSIX_SYNCHRONIZED_IO
	       are defined or the implementation supports the
	       lio_listio() function as	described in System Interfaces
	       and Headers, Issue 5:
		 When synchronized I/O is enabled on the file
		 associated with list[n]->aio_fildes the behavior of
		 the operation initiated by a call to lio_listio() is
		 as per	the definitions	of synchronized	I/O data
		 integrity and synchronized I/O	file integrity.
		 Reason	for omission: It is not	possible to determine
		 in a portable manner whether data has been written to
		 the file-system.

	  2    If _POSIX_ASYNCHRONOUS_IO and _POSIX_PRIORITIZED_IO are
	       defined or the implementation supports the lio_listio()
	       function	as described in	System Interfaces and Headers,
	       Issue 5:
		 When prioritized requests to the same file generated
		 by calls to lio_listio() are blocked waiting for a
		 resource, higher priority requests shall be granted
		 the resource before lower priority requests.
		 Reason	for omission: There is no portable test	method
		 for this requirement.

	  3    If _POSIX_ASYNCHRONOUS_IO is defined or the



     Page 9					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall return -1	and set	errno
		 to EAGAIN when	the resources necessary	to queue all
		 the I/O requests are not available.
		 Reason	for omission: This is no reliable test method
		 for this assertion.

	  4    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	shall return -1	and set	errno
		 to EAGAIN when	list[n]->aio_lio_opcode	is LIO_READ
		 and the requested asynchronous	I/O operation is not
		 queued	due to temporary resource limitations.
		 Reason	for omission: This is no reliable test method
		 for this assertion.

	  5    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 A call	to lio_listio()	when list[n].aio_lio_opcode is
		 LIO_WRITE shall return	-1 and set errno to EAGAIN
		 when the requested asynchronous I/O operation is not
		 queued	due to system resource limitations.
		 Reason	for omission: This is no reliable test method
		 for this assertion.

	  6    If _POSIX_ASYNCHRONOUS_IO is defined or the
	       implementation supports the lio_listio()	function as
	       described in System Interfaces and Headers, Issue 5:
		 On a call to lio_listio() when	list[n].aio_lio_opcode
		 is LIO_WRITE and list[n]->aio_nbytes is not a valid
		 value the return status of the	asynchronous operation
		 shall be set to -1 and	its error status shall be set
		 to EINVAL.
		 Reason	for omission: This is no reliable test method
		 for this assertion.

     Notes
	  Tests	must be	run against a file type	which is capable of
	  seeking and for which	the implementation supports the
	  necessary types of Realtime I/O and provides appropriate
	  files	for testing.

	  The existence	of such	files is assumed as a prerequisite in
	  these	tests.

     RELEASE
	  Release VSRT 5.1.1
	  Copyright (c)	1997 X/Open Company Ltd., A member of The Open
	  Group.



     Page 10					    (printed 2/21/103)






     lio_listio(rt.os/aiVSRT 5.1.1 (The	Open Groulio_listio(rt.os/aio)



	  All rights reserved






















































     Page 11					    (printed 2/21/103)



