Lines Matching full:the
8 * 2017/12/30 Bernard The first version.
25 * The aio_cancel() function shall attempt to cancel one or more asynchronous I/O
26 * requests currently outstanding against file descriptor fildes. The aiocbp
27 * argument points to the asynchronous I/O control block for a particular request
33 * then the normal asynchronous completion process shall take place for those
36 * For requested operations that are successfully canceled, the associated error
37 * status shall be set to [ECANCELED] and the return status shall be -1. For
38 * requested operations that are not successfully canceled, the aiocbp shall not
41 * If aiocbp is not NULL, then if fildes does not have the same value as the file
42 * descriptor with which the asynchronous operation was initiated, unspecified results occur.
64 * The aio_error() function shall return the error status associated with the
65 * aiocb structure referenced by the aiocbp argument. The error status for an
66 * asynchronous I/O operation is the errno value that would be set by the corresponding
80 * The aio_fsync() function shall asynchronously perform a file synchronization
81 * operation, as specified by the op argument, for I/O operations associated with
82 * the file indicated by the file descriptor aio_fildes member of the aiocb
83 * structure referenced by the aiocbp argument and queued at the time of the
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
94 * completion. If the aio_fsync() function fails, or if the operation queued by
98 * If aio_fsync() succeeds, then it is only the I/O that was queued at the time
99 * of the call to aio_fsync() that is guaranteed to be forced to the relevant
100 * completion state. The completion of subsequent I/O on the file descriptor is
103 * The aiocbp argument refers to an asynchronous I/O control block. The aiocbp
105 * determine the error status and return status, respectively, of the asynchronous
106 * operation while it is proceeding. When the request is queued, the error status
107 * for the operation is [EINPROGRESS]. When all data has been successfully transferred,
108 * the error status shall be reset to reflect the success or failure of the operation.
109 * If the operation does not complete successfully, the error status for the
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
113 * other members of the structure referenced by aiocbp are ignored. If the control
115 * I/O completion, then the behavior is undefined.
117 * If the aio_fsync() function fails or aiocbp indicates an error condition,
180 * The aio_read() function shall read aiocbp->aio_nbytes from the file associated
181 * with aiocbp->aio_fildes into the buffer pointed to by aiocbp->aio_buf. The
182 * function call shall return when the read request has been initiated or queued
183 * to the file or device (even when the data cannot be delivered immediately).
185 * If prioritized I/O is supported for this file, then the asynchronous operation
188 * the base scheduling priority is that of the calling process;
190 * otherwise, the base scheduling priority is that of the calling thread.
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
194 * the asynchronous operation while it is proceeding. If an error condition is
195 * encountered during queuing, the function call shall return without having
196 * initiated or queued the request. The requested operation takes place at the
197 * absolute position in the file as given by aio_offset, as if lseek() were called
198 * immediately prior to the operation with an offset equal to aio_offset and a
200 * I/O operation, the value of the file offset for the file is unspecified.
202 * The aio_sigevent member specifies the notification which occurs when the
205 * The aiocbp->aio_lio_opcode field shall be ignored by aio_read().
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.
211 * Simultaneous asynchronous operations using the same aiocbp produce undefined
214 * If synchronized I/O is enabled on the file associated with aiocbp->aio_fildes,
215 * the behavior of this function shall be according to the definitions of synchronized
218 * For any system action that changes the process memory space while an asynchronous
219 * I/O is outstanding to the address range being changed, the result of that action
222 * For regular files, no data transfer shall occur past the offset maximum
223 * established in the open file description associated with aiocbp->aio_fildes.
245 * The aio_return() function shall return the return status associated with the
246 * aiocb structure referenced by the aiocbp argument. The return status for an
247 * asynchronous I/O operation is the value that would be returned by the corresponding
248 * read(), write(), or fsync() function call. If the error status for the operation
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
251 * status of a given asynchronous operation; thereafter, if the same aiocb structure
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
271 * The aio_suspend() function shall suspend the calling thread until at least
272 * one of the asynchronous I/O operations referenced by the list argument has
273 * completed, until a signal interrupts the function, or, if timeout is not NULL,
274 * until the time interval specified by timeout has passed. If any of the aiocb
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])
277 * at the time of the call, the function shall return without suspending the
278 * calling thread. The list argument is an array of pointers to asynchronous I/O
279 * control blocks. The nent argument indicates the number of elements in the
284 * I/O, the effect is undefined.
286 * If the time interval indicated in the timespec structure pointed to by timeout
287 * passes before any of the I/O operations referenced by list are completed, then
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
328 * function shall return when the write request has been initiated or, at a minimum,
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.
339 * If O_APPEND is not set for the file descriptor aio_fildes, then the requested
340 * operation shall take place at the absolute position in the file as given by
341 * aio_offset, as if lseek() were called immediately prior to the operation with
343 * set for the file descriptor, or if aio_fildes is associated with a device that
344 * is incapable of seeking, write operations append to the file in the same order
345 * as the calls were made, except under circumstances described in Asynchronous
346 * I/O. After a successful call to enqueue an asynchronous I/O operation, the value
347 * of the file offset for the file is unspecified.
349 * The aio_sigevent member specifies the notification which occurs when the request
352 * The aiocbp->aio_lio_opcode field shall be ignored by aio_write().
354 * Simultaneous asynchronous operations using the same aiocbp produce undefined
357 * If synchronized I/O is enabled on the file associated with aiocbp->aio_fildes,
358 * the behavior of this function shall be according to the definitions of synchronized
361 * For regular files, no data transfer shall occur past the offset maximum established
362 * in the open file description associated with aiocbp->aio_fildes.
388 * The lio_listio() function shall initiate a list of I/O requests with a single
391 * The mode argument takes one of the values LIO_WAIT or LIO_NOWAIT declared in
392 * <aio.h> and determines whether the function returns when the I/O operations
393 * have been completed, or as soon as the operations have been queued. If the
394 * mode argument is LIO_WAIT, the function shall wait until all I/O is complete
395 * and the sig argument shall be ignored.
397 * If the mode argument is LIO_NOWAIT, the function shall return immediately, and
398 * asynchronous notification shall occur, according to the sig argument, when all
399 * the I/O operations complete. If sig is NULL, then no asynchronous notification
401 * in Signal Generation and Delivery when all the requests in list have completed.
403 * The I/O requests enumerated by list are submitted in an unspecified order.
405 * The list argument is an array of pointers to aiocb structures. The array contains
406 * nent elements. The array may contain NULL elements, which shall be ignored.
408 * If the buffer pointed to by list or the aiocb structures pointed to by the
409 * elements of the array list become illegal addresses before all asynchronous I/O
410 * completed and, if necessary, the notification is sent, then the behavior is
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
413 * the asynchronous I/O associated with that aiocb structure being completed, the
416 * The aio_lio_opcode field of each aiocb structure specifies the operation to be
417 * performed. The supported operations are LIO_READ, LIO_WRITE, and LIO_NOP; these
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
435 * when used by the aio_read() and aio_write() functions.
437 * The nent argument specifies how many elements are members of the list; that is,
438 * the length of the array.
440 * The behavior of this function is altered according to the definitions of synchronized
442 * synchronized I/O is enabled on the file associated with aio_fildes.
444 * For regular files, no data transfer shall occur past the offset maximum established
445 * in the open file description associated with aiocbp->aio_fildes.
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