Lines Matching full:to
25 * The aio_cancel() function shall attempt to cancel one or more asynchronous I/O
27 * argument points to the asynchronous I/O control block for a particular request
28 * to be canceled. If aiocbp is NULL, then all outstanding cancelable asynchronous
37 * status shall be set to [ECANCELED] and the return status shall be -1. For
84 * call to aio_fsync(). The function call shall return when the synchronization
85 * request has been initiated or queued to the file or device (even when the data
89 * as if by a call to fdatasync(); that is, as defined for synchronized I/O data
93 * as if by a call to fsync(); that is, as defined for synchronized I/O file integrity
95 * aio_fsync() fails, then outstanding I/O operations are not guaranteed to have
99 * of the call to aio_fsync() that is guaranteed to be forced to the relevant
101 * not guaranteed to be completed in a synchronized fashion.
103 * The aiocbp argument refers to an asynchronous I/O control block. The aiocbp
104 * value may be used as an argument to aio_error() and aio_return() in order to
108 * the error status shall be reset to reflect the success or failure of the operation.
110 * operation shall be set to indicate the error. The aio_sigevent member determines
111 * the asynchronous notification to occur as specified in Signal Generation and
114 * block referenced by aiocbp becomes an illegal address prior to asynchronous
118 * data is not guaranteed to have been successfully transferred.
164 /* seek to offset */ in aio_read_work()
181 * with aiocbp->aio_fildes into the buffer pointed to by aiocbp->aio_buf. The
183 * to the file or device (even when the data cannot be delivered immediately).
186 * shall be submitted at a priority equal to a base scheduling priority minus
192 * The aiocbp value may be used as an argument to aio_error() and aio_return()
193 * in order to determine the error status and return status, respectively, of
198 * immediately prior to the operation with an offset equal to aio_offset and a
199 * whence equal to SEEK_SET. After a successful call to enqueue an asynchronous
207 * The aiocbp argument points to an aiocb structure. If the buffer pointed to by
208 * aiocbp->aio_buf or the control block pointed to by aiocbp becomes an illegal
209 * address prior to asynchronous I/O completion, then the behavior is undefined.
215 * the behavior of this function shall be according to the definitions of synchronized
219 * I/O is outstanding to the address range being changed, the result of that action
249 * is equal to [EINPROGRESS], then the return status for the operation is undefined.
250 * The aio_return() function may be called exactly once to retrieve the return
252 * is used in a call to aio_return() or aio_error(), an error may be returned.
253 * When the aiocb structure referred to by aiocbp is used to submit another asynchronous
254 * operation, then aio_return() may be successfully used to retrieve the return
275 * structures in the list correspond to completed asynchronous I/O operations
276 * (that is, the error status for the operation is not equal to [EINPROGRESS])
278 * calling thread. The list argument is an array of pointers to asynchronous I/O
280 * array. Each aiocb structure pointed to has been used in initiating an asynchronous
283 * that refer to aiocb structures that have not been used in submitting asynchronous
286 * If the time interval indicated in the timespec structure pointed to by timeout
326 * The aio_write() function shall write aiocbp->aio_nbytes to the file associated
327 * with aiocbp->aio_fildes from the buffer pointed to by aiocbp->aio_buf. The
329 * queued to the file or device.
331 * The aiocbp argument may be used as an argument to aio_error() and aio_return()
332 * in order to determine the error status and return status, respectively, of the
335 * The aiocbp argument points to an aiocb structure. If the buffer pointed to by
336 * aiocbp->aio_buf or the control block pointed to by aiocbp becomes an illegal
337 * address prior to asynchronous I/O completion, then the behavior is undefined.
341 * aio_offset, as if lseek() were called immediately prior to the operation with
342 * an offset equal to aio_offset and a whence equal to SEEK_SET. If O_APPEND is
344 * is incapable of seeking, write operations append to the file in the same order
346 * I/O. After a successful call to enqueue an asynchronous I/O operation, the value
358 * the behavior of this function shall be according to the definitions of synchronized
398 * asynchronous notification shall occur, according to the sig argument, when all
405 * The list argument is an array of pointers to aiocb structures. The array contains
408 * If the buffer pointed to by list or the aiocb structures pointed to by the
411 * undefined. If the buffers pointed to by the aio_buf member of the aiocb structure
412 * pointed to by the elements of the array list become illegal addresses prior to
416 * The aio_lio_opcode field of each aiocb structure specifies the operation to be
418 * symbols are defined in <aio.h>. The LIO_NOP operation causes the list entry to
419 * be ignored. If the aio_lio_opcode element is equal to LIO_READ, then an I/O operation
420 * is submitted as if by a call to aio_read() with the aiocbp equal to the address
421 * of the aiocb structure. If the aio_lio_opcode element is equal to LIO_WRITE, then
422 * an I/O operation is submitted as if by a call to aio_write() with the aiocbp equal
423 * to the address of the aiocb structure.
425 * The aio_fildes member specifies the file descriptor on which the operation is to
428 * The aio_buf member specifies the address of the buffer to or from which the data
431 * The aio_nbytes member specifies the number of bytes of data to be transferred.
433 * The members of the aiocb structure further describe the I/O operation to be
434 * performed, in a manner identical to that of the corresponding aiocb structure
440 * The behavior of this function is altered according to the definitions of synchronized
448 * non-null pointer and the block pointed to by this pointer becomes an illegal
449 * address prior to all asynchronous I/O being completed, then the behavior is