xnu-6153.121.1.tar.gz

[apple/xnu.git] / bsd / sys / aio.h

diff --git a/bsd/sys/aio.h b/bsd/sys/aio.h
index f2d41b32c11d01295cfcb74390a4d6e19875a922..7f4feaa5ce7946591992e40cc7f2961e61108c14 100644 (file)
--- a/bsd/sys/aio.h
+++ b/bsd/sys/aio.h
@@ -1,69 +1,114 @@
 /*
 /*

- * Copyright (c) 2003-2005 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003-2006 Apple Computer, Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
- * 
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
- * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * @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,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
+ * 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
  *
  *     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_
 
 #ifndef _SYS_AIO_H_

-#define        _SYS_AIO_H_
+#define _SYS_AIO_H_

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

+#include <sys/_types.h>

 #include <sys/cdefs.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 {
 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 */
+       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 */

 
 

-// LP64todo - should this move?

 #ifdef KERNEL
 
 #ifdef KERNEL
 

-#if __DARWIN_ALIGN_NATURAL
-#pragma options align=natural
-#endif
-

 struct user_aiocb {
 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 */
+       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 */

 };
 
 };
 

-#if __DARWIN_ALIGN_NATURAL
-#pragma options align=reset
-#endif
+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
 
 
 #endif // KERNEL
 


@@ -75,25 +120,25 @@ struct user_aiocb {
  * none of the requested operations could be canceled since they are
  * already complete.
  */
  * none of the requested operations could be canceled since they are
  * already complete.
  */

-#define        AIO_ALLDONE                     0x1
+#define AIO_ALLDONE                     0x1

 
 /* all requested operations have been canceled */
 
 /* all requested operations have been canceled */

-#define        AIO_CANCELED            0x2
+#define AIO_CANCELED            0x2

 
 /*
  * some of the requested operations could not be canceled since
  * they are in progress
  */
 
 /*
  * some of the requested operations could not be canceled since
  * they are in progress
  */

-#define        AIO_NOTCANCELED         0x4
+#define AIO_NOTCANCELED         0x4

 
 
 /*
  * lio_listio operation options
  */
 
 
 
 /*
  * 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 */
+#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
 
 /*
  * lio_listio() modes


@@ -105,33 +150,20 @@ struct user_aiocb {
  * the lio_listio() operation is being performed, and no
  * notification is given when the operation is complete
  */
  * the lio_listio() operation is being performed, and no
  * notification is given when the operation is complete
  */

-#define        LIO_NOWAIT              0x1
+#define LIO_NOWAIT              0x1

 
 /*
  * A lio_listio() synchronization operation indicating
  * that the calling thread is to suspend until the
  * lio_listio() operation is complete.
  */
 
 /*
  * A lio_listio() synchronization operation indicating
  * that the calling thread is to suspend until the
  * lio_listio() operation is complete.
  */

-#define        LIO_WAIT                0x2
+#define LIO_WAIT                0x2

 
 /*
  * Maximum number of operations in single lio_listio call
  */
 
 /*
  * Maximum number of operations in single lio_listio call
  */

-#define        AIO_LISTIO_MAX          16
-
-/*
- * 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
- */
+#define AIO_LISTIO_MAX          16

 
 

-#ifndef O_SYNC /* XXX investigate documentation error */
-#define        O_SYNC                  0x0080  /* queued IO is completed as if by fsync() */
-#endif
-#if 0 /* O_DSYNC - NOT SUPPORTED */
-#define        O_DSYNC                 0x1             /* queued async IO is completed as if by fdatasync() */
-#endif

 
 #ifndef KERNEL
 /*
 
 #ifndef KERNEL
 /*


@@ -141,116 +173,116 @@ struct user_aiocb {
 __BEGIN_DECLS
 
 /*
 __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 
+ * 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.
  */
  * all outstanding cancelable asynchronous I/O requests against fd shall be canceled.
  */

-int            aio_cancel( int fd, 
-                                       struct aiocb * aiocbp );
-                                       
+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 
+ * 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()
  * 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 
+ * operation.  If the operation has not yet completed, then the error status shall

  * be equal to [EINPROGRESS].
  */
  * be equal to [EINPROGRESS].
  */

-int            aio_error( const struct aiocb * aiocbp );
+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 
+ * 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.
  * 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 
+ * 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.
  */
  * of the operation.
  */

-int            aio_fsync( int op, 
-                                  struct aiocb * aiocbp );
-                                  
+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 
+ * 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 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 
+ * 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.
  */
  * I/O operation, the value of the file offset for the file is unspecified.
  */

-int            aio_read( struct aiocb * aiocbp );
+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. 
+ * 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
  * When the aiocb structure referred to by aiocbp is used to submit another

- * asynchronous operation, then aio_return() may be successfully used to 
+ * asynchronous operation, then aio_return() may be successfully used to

  * retrieve the return status of that operation.
  */
  * retrieve the return status of that operation.
  */

-ssize_t        aio_return( struct aiocb * aiocbp );
+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 
+ * 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.
  */
  * array may contain NULL pointers, which are ignored.
  */

-int            aio_suspend( const struct aiocb *const aiocblist[], 
-                                        int nent,
-                                        const struct timespec * timeoutp );
-                                        
+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 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.
  * 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 
+ * 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.
  */
  * asynchronous operation while it is proceeding.
  */

-int            aio_write( struct aiocb * aiocbp );
+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 
+ * 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.
  */
  * 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 );
+int             lio_listio( int mode,
+    struct aiocb *const aiocblist[],
+    int nent,
+    struct sigevent *sigp );

 __END_DECLS
 
 #endif /* KERNEL */
 __END_DECLS
 
 #endif /* KERNEL */