1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
|
/*
* 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>
#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>
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 */
};
/*
* 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
/*
* 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 /* _SYS_AIO_H_ */
|
