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
|
/****************************************************************************
* fs/aio/aio.h
*
* Copyright (C) 2014 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __FS_AIO_AIO_H
#define __FS_AIO_AIO_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <aio.h>
#include <queue.h>
#include <nuttx/wqueue.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
/* Number of pre-allocated AIO Control block containers */
#ifndef CONFIG_FS_NAIOC
# define CONFIG_FS_NAIOC 8
#endif
/****************************************************************************
* Public Types
****************************************************************************/
/* This structure contains one AIO control block and appends information
* needed by the logic running on the worker thread. These structures are
* pre-allocated, the number pre-allocated controlled by CONFIG_FS_NAIOC.
*/
struct file;
struct aio_container_s
{
dq_entry_t aioc_link; /* Supports a doubly linked list */
FAR struct aiocb *aioc_aiocbp; /* The contained AIO control block */
FAR struct file *aioc_filep; /* File structure to use with the I/O */
struct work_s aioc_work; /* Used to defer I/O to the work thread */
pid_t aioc_pid; /* ID of the waiting task */
uint8_t aioc_prio; /* Priority of the waiting task */
};
/****************************************************************************
* Public Data
****************************************************************************/
#undef EXTERN
#if defined(__cplusplus)
#define EXTERN extern "C"
extern "C"
{
#else
#define EXTERN extern
#endif
/* This is a list of pending asynchronous I/O. The user must hold the
* lock on this list in order to access the list.
*/
EXTERN dq_queue_t g_aio_pending;
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
/****************************************************************************
* Name: aio_initialize
*
* Description:
* Perform one-time initialization of the asynchronous I/O sub-system
*
* Input Parameters:
* None
*
* Returned Value:
* None
*
****************************************************************************/
void aio_initialize(void);
/****************************************************************************
* Name: aio_lock/aio_unlock
*
* Description:
* Take/give the lock on the pending asynchronous I/O list
*
* Input Parameters:
* None
*
* Returned Value:
* None
*
****************************************************************************/
void aio_lock(void);
void aio_unlock(void);
/****************************************************************************
* Name: aioc_alloc
*
* Description:
* Allocate a new AIO container by taking the next, pre-allocated
* container from the free list. This function will wait until
* aioc_free() is called in the event that there is no free container
* available in the free list.
*
* Input Parameters:
* None
*
* Returned Value:
* A reference to the allocated AIO container. This allocation never
* fails because the logic will wait in the event that there is no free
* container.
*
****************************************************************************/
FAR struct aio_container_s *aioc_lock(void);
/****************************************************************************
* Name: aioc_free
*
* Description:
* Free an AIO container by returning it to the free list and, perhaps,
* awakening any threads waiting for that resource
*
* Input Parameters:
* aioc - The AIO container to be free
*
* Returned Value:
* None
*
****************************************************************************/
void aioc_free(FAR struct aio_container_s *aioc);
/****************************************************************************
* Name: aio_contain
*
* Description:
* Create and initialize a container for the provided AIO control block
*
* Input Parameters:
* aiocbp - The AIO control block pointer
*
* Returned Value:
* A reference to the new AIO control block container. This function
* will not fail but will wait if necessary for the resources to perform
* this operation. NULL will be returned on certain errors with the
* errno value already set appropriately.
*
****************************************************************************/
FAR struct aio_container_s *aio_contain(FAR struct aiocb *aiocbp);
/****************************************************************************
* Name: aioc_decant
*
* Description:
* Remove the AIO control block from the container and free all resources
* used by the container.
*
* Input Parameters:
* aioc - Pointer to the AIO control block container
*
* Returned Value:
* A pointer to the no-longer contained AIO control block.
*
****************************************************************************/
FAR struct aiocb *aioc_decant(FAR struct aio_container_s *aioc);
/****************************************************************************
* Name: aio_signal
*
* Description:
* Signal the client that an I/O has completed.
*
* Input Parameters:
* pid - ID of the task to signal
* aiocbp - Pointer to the asynchronous I/O state structure that includes
* information about how to signal the client
*
* Returned Value:
* Zero (OK) if the client was successfully signalled. Otherwise, a
* negated errno value is returned.
*
****************************************************************************/
int aio_signal(pid_t pid, FAR struct aiocb *aiocbp);
#endif /* __FS_AIO_AIO_H */
|
