darling-xnu/bsd/sys/aio.h

/*
 * Copyright (c) 2003-2006 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 *	File:	sys/aio.h
 *	Author:	Umesh Vaishampayan [umeshv@apple.com]
 *			05-Feb-2003	umeshv	Created.
 *
 *	Header file for POSIX Asynchronous IO APIs
 *
 */

#ifndef _SYS_AIO_H_
#define _SYS_AIO_H_

#include <sys/signal.h>
#include <sys/_types.h>
#include <sys/cdefs.h>

/*
 * [XSI] Inclusion of the <aio.h> header may make visible symbols defined
 * in the headers <fcntl.h>, <signal.h>, <sys/types.h>, and <time.h>.
 *
 * In our case, this is limited to struct timespec, off_t and ssize_t.
 */
#include <sys/_types/_timespec.h>
#ifdef KERNEL
#include <sys/_types/_user64_timespec.h>
#include <sys/_types/_user32_timespec.h>
#endif /* KERNEL */

#include <sys/_types/_off_t.h>
#include <sys/_types/_ssize_t.h>

/*
 * A aio_fsync() options that the calling thread is to continue execution
 * while the lio_listio() operation is being performed, and no notification
 * is given when the operation is complete
 *
 * [XSI] from <fcntl.h>
 */
#include <sys/_types/_o_sync.h>
#include <sys/_types/_o_dsync.h>

#ifndef KERNEL
struct aiocb {
	int             aio_fildes;             /* File descriptor */
	off_t           aio_offset;             /* File offset */
	volatile void   *aio_buf;               /* Location of buffer */
	size_t          aio_nbytes;             /* Length of transfer */
	int             aio_reqprio;            /* Request priority offset */
	struct sigevent aio_sigevent;           /* Signal number and value */
	int             aio_lio_opcode;         /* Operation to be performed */
};
#endif /* KERNEL */

#ifdef KERNEL

struct user_aiocb {
	int             aio_fildes;             /* File descriptor */
	off_t           aio_offset; /* File offset */
	user_addr_t     aio_buf;                /* Location of buffer */
	user_size_t     aio_nbytes;             /* Length of transfer */
	int             aio_reqprio;    /* Request priority offset */
	struct user_sigevent aio_sigevent;      /* Signal number and value */
	int             aio_lio_opcode;         /* Operation to be performed */
};

struct user64_aiocb {
	int             aio_fildes;             /* File descriptor */
	user64_off_t            aio_offset; /* File offset */
	user64_addr_t   aio_buf;                /* Location of buffer */
	user64_size_t   aio_nbytes;             /* Length of transfer */
	int             aio_reqprio;    /* Request priority offset */
	struct user64_sigevent aio_sigevent;    /* Signal number and value */
	int             aio_lio_opcode;         /* Operation to be performed */
};

struct user32_aiocb {
	int             aio_fildes;             /* File descriptor */
	user32_off_t            aio_offset;             /* File offset */
	user32_addr_t   aio_buf;                /* Location of buffer */
	user32_size_t   aio_nbytes;             /* Length of transfer */
	int             aio_reqprio;            /* Request priority offset */
	struct user32_sigevent  aio_sigevent;           /* Signal number and value */
	int             aio_lio_opcode;         /* Operation to be performed */
};

#endif // KERNEL

/*
 * aio_cancel() return values
 */

/*
 * none of the requested operations could be canceled since they are
 * already complete.
 */
#define AIO_ALLDONE                     0x1

/* all requested operations have been canceled */
#define AIO_CANCELED            0x2

/*
 * some of the requested operations could not be canceled since
 * they are in progress
 */
#define AIO_NOTCANCELED         0x4


/*
 * lio_listio operation options
 */

#define LIO_NOP                 0x0     /* option indicating that no transfer is requested */
#define LIO_READ                0x1             /* option requesting a read */
#define LIO_WRITE               0x2             /* option requesting a write */

/*
 * lio_listio() modes
 */

/*
 * A lio_listio() synchronization operation indicating
 * that the calling thread is to continue execution while
 * the lio_listio() operation is being performed, and no
 * notification is given when the operation is complete
 */
#define LIO_NOWAIT              0x1

/*
 * A lio_listio() synchronization operation indicating
 * that the calling thread is to suspend until the
 * lio_listio() operation is complete.
 */
#define LIO_WAIT                0x2

/*
 * Maximum number of operations in single lio_listio call
 */
#define AIO_LISTIO_MAX          16


#ifndef KERNEL
/*
 * Prototypes
 */

__BEGIN_DECLS

/*
 * Attempt to cancel one or more asynchronous I/O requests currently outstanding
 * against file descriptor fd. The aiocbp argument points to the asynchronous I/O
 * control block for a particular request to be canceled.  If aiocbp is NULL, then
 * all outstanding cancelable asynchronous I/O requests against fd shall be canceled.
 */
int             aio_cancel( int fd,
    struct aiocb * aiocbp );

/*
 * Return the error status associated with the aiocb structure referenced by the
 * aiocbp argument. The error status for an asynchronous I/O operation is the errno
 * value that would be set by the corresponding read(), write(),  or fsync()
 * operation.  If the operation has not yet completed, then the error status shall
 * be equal to [EINPROGRESS].
 */
int             aio_error( const struct aiocb * aiocbp );

/*
 * Asynchronously force all I/O operations associated with the file indicated by
 * the file descriptor aio_fildes member of the aiocb structure referenced by the
 * aiocbp argument and queued at the time of the call to aio_fsync() to the
 * synchronized I/O completion state.  The function call shall return when the
 * synchronization request has been initiated or queued.  op O_SYNC is the only
 * supported opertation at this time.
 * The aiocbp argument refers to an asynchronous I/O control block. The aiocbp
 * value may be used as an argument to aio_error() and aio_return() in order to
 * determine the error status and return status, respectively, of the asynchronous
 * operation while it is proceeding.  When the request is queued, the error status
 * for the operation is [EINPROGRESS]. When all data has been successfully
 * transferred, the error status shall be reset to reflect the success or failure
 * of the operation.
 */
int             aio_fsync( int op,
    struct aiocb * aiocbp );

/*
 * Read aiocbp->aio_nbytes from the file associated with aiocbp->aio_fildes into
 * the buffer pointed to by aiocbp->aio_buf.  The function call shall return when
 * the read request has been initiated or queued.
 * The aiocbp value may be used as an argument to aio_error() and aio_return() in
 * order to determine the error status and return status, respectively, of the
 * asynchronous operation while it is proceeding. If an error condition is
 * encountered during queuing, the function call shall return without having
 * initiated or queued the request. The requested operation takes place at the
 * absolute position in the file as given by aio_offset, as if lseek() were called
 * immediately prior to the operation with an offset equal to aio_offset and a
 * whence equal to SEEK_SET.  After a successful call to enqueue an asynchronous
 * I/O operation, the value of the file offset for the file is unspecified.
 */
int             aio_read( struct aiocb * aiocbp );

/*
 * Return the return status associated with the aiocb structure referenced by
 * the aiocbp argument.  The return status for an asynchronous I/O operation is
 * the value that would be returned by the corresponding read(), write(), or
 * fsync() function call.  If the error status for the operation is equal to
 * [EINPROGRESS], then the return status for the operation is undefined.  The
 * aio_return() function may be called exactly once to retrieve the return status
 * of a given asynchronous operation; thereafter, if the same aiocb structure
 * is used in a call to aio_return() or aio_error(), an error may be returned.
 * When the aiocb structure referred to by aiocbp is used to submit another
 * asynchronous operation, then aio_return() may be successfully used to
 * retrieve the return status of that operation.
 */
ssize_t aio_return( struct aiocb * aiocbp );

/*
 * Suspend the calling thread until at least one of the asynchronous I/O
 * operations referenced by the aiocblist argument has completed, until a signal
 * interrupts the function, or, if timeout is not NULL, until the time
 * interval specified by timeout has passed.  If any of the aiocb structures
 * in the aiocblist correspond to completed asynchronous I/O operations (that is,
 * the error status for the operation is not equal to [EINPROGRESS]) at the
 * time of the call, the function shall return without suspending the calling
 * thread.  The aiocblist argument is an array of pointers to asynchronous I/O
 * control blocks.  The nent argument indicates the number of elements in the
 * array.  Each aiocb structure pointed to has been used in initiating an
 * asynchronous I/O request via aio_read(), aio_write(), or lio_listio(). This
 * array may contain NULL pointers, which are ignored.
 */
int             aio_suspend( const struct aiocb *const aiocblist[],
    int nent,
    const struct timespec * timeoutp ) __DARWIN_ALIAS_C(aio_suspend);

/*
 * Write aiocbp->aio_nbytes to the file associated with aiocbp->aio_fildes from
 * the buffer pointed to by aiocbp->aio_buf.  The function shall return when the
 * write request has been initiated or, at a minimum, queued.
 * The aiocbp argument may be used as an argument to aio_error() and aio_return()
 * in order to determine the error status and return status, respectively, of the
 * asynchronous operation while it is proceeding.
 */
int             aio_write( struct aiocb * aiocbp );

/*
 * Initiate a list of I/O requests with a single function call.  The mode
 * argument takes one of the values LIO_WAIT or LIO_NOWAIT and determines whether
 * the function returns when the I/O operations have been completed, or as soon
 * as the operations have been queued.  If the mode argument is LIO_WAIT, the
 * function shall wait until all I/O is complete and the sig argument shall be
 * ignored.
 * If the mode argument is LIO_NOWAIT, the function shall return immediately, and
 * asynchronous notification shall occur, according to the sig argument, when all
 * the I/O operations complete.  If sig is NULL, then no asynchronous notification
 * shall occur.
 */
int             lio_listio( int mode,
    struct aiocb *const aiocblist[],
    int nent,
    struct sigevent *sigp );
__END_DECLS

#endif /* KERNEL */
#endif /* _SYS_AIO_H_ */