]>
Commit | Line | Data |
---|---|---|
a76bab49 AL |
1 | /* |
2 | * QEMU aio implementation | |
3 | * | |
4 | * Copyright IBM, Corp. 2008 | |
5 | * | |
6 | * Authors: | |
7 | * Anthony Liguori <aliguori@us.ibm.com> | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
10 | * the COPYING file in the top-level directory. | |
11 | * | |
12 | */ | |
13 | ||
14 | #ifndef QEMU_AIO_H | |
15 | #define QEMU_AIO_H | |
16 | ||
17 | #include "qemu-common.h" | |
1de7afc9 PB |
18 | #include "qemu/queue.h" |
19 | #include "qemu/event_notifier.h" | |
a76bab49 | 20 | |
85e8dab1 PB |
21 | typedef struct BlockDriverAIOCB BlockDriverAIOCB; |
22 | typedef void BlockDriverCompletionFunc(void *opaque, int ret); | |
23 | ||
d7331bed | 24 | typedef struct AIOCBInfo { |
85e8dab1 | 25 | void (*cancel)(BlockDriverAIOCB *acb); |
8c82e9a4 | 26 | size_t aiocb_size; |
d7331bed | 27 | } AIOCBInfo; |
85e8dab1 PB |
28 | |
29 | struct BlockDriverAIOCB { | |
d7331bed | 30 | const AIOCBInfo *aiocb_info; |
85e8dab1 PB |
31 | BlockDriverState *bs; |
32 | BlockDriverCompletionFunc *cb; | |
33 | void *opaque; | |
85e8dab1 PB |
34 | }; |
35 | ||
d7331bed | 36 | void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, |
85e8dab1 PB |
37 | BlockDriverCompletionFunc *cb, void *opaque); |
38 | void qemu_aio_release(void *p); | |
39 | ||
f627aab1 PB |
40 | typedef struct AioHandler AioHandler; |
41 | typedef void QEMUBHFunc(void *opaque); | |
42 | typedef void IOHandler(void *opaque); | |
43 | ||
44 | typedef struct AioContext { | |
e3713e00 PB |
45 | GSource source; |
46 | ||
a915f4bc PB |
47 | /* The list of registered AIO handlers */ |
48 | QLIST_HEAD(, AioHandler) aio_handlers; | |
49 | ||
50 | /* This is a simple lock used to protect the aio_handlers list. | |
51 | * Specifically, it's used to ensure that no callbacks are removed while | |
52 | * we're walking and dispatching callbacks. | |
53 | */ | |
54 | int walking_handlers; | |
55 | ||
f627aab1 PB |
56 | /* Anchor of the list of Bottom Halves belonging to the context */ |
57 | struct QEMUBH *first_bh; | |
58 | ||
59 | /* A simple lock used to protect the first_bh list, and ensure that | |
60 | * no callbacks are removed while we're walking and dispatching callbacks. | |
61 | */ | |
62 | int walking_bh; | |
2f4dc3c1 PB |
63 | |
64 | /* Used for aio_notify. */ | |
65 | EventNotifier notifier; | |
6b5f8762 SH |
66 | |
67 | /* GPollFDs for aio_poll() */ | |
68 | GArray *pollfds; | |
9b34277d SH |
69 | |
70 | /* Thread pool for performing work and receiving completion callbacks */ | |
71 | struct ThreadPool *thread_pool; | |
f627aab1 PB |
72 | } AioContext; |
73 | ||
a76bab49 | 74 | /* Returns 1 if there are still outstanding AIO requests; 0 otherwise */ |
9958c351 | 75 | typedef int (AioFlushEventNotifierHandler)(EventNotifier *e); |
a76bab49 | 76 | |
f627aab1 PB |
77 | /** |
78 | * aio_context_new: Allocate a new AioContext. | |
79 | * | |
80 | * AioContext provide a mini event-loop that can be waited on synchronously. | |
81 | * They also provide bottom halves, a service to execute a piece of code | |
82 | * as soon as possible. | |
83 | */ | |
84 | AioContext *aio_context_new(void); | |
85 | ||
e3713e00 PB |
86 | /** |
87 | * aio_context_ref: | |
88 | * @ctx: The AioContext to operate on. | |
89 | * | |
90 | * Add a reference to an AioContext. | |
91 | */ | |
92 | void aio_context_ref(AioContext *ctx); | |
93 | ||
94 | /** | |
95 | * aio_context_unref: | |
96 | * @ctx: The AioContext to operate on. | |
97 | * | |
98 | * Drop a reference to an AioContext. | |
99 | */ | |
100 | void aio_context_unref(AioContext *ctx); | |
101 | ||
f627aab1 PB |
102 | /** |
103 | * aio_bh_new: Allocate a new bottom half structure. | |
104 | * | |
105 | * Bottom halves are lightweight callbacks whose invocation is guaranteed | |
106 | * to be wait-free, thread-safe and signal-safe. The #QEMUBH structure | |
107 | * is opaque and must be allocated prior to its use. | |
108 | */ | |
109 | QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque); | |
110 | ||
2f4dc3c1 PB |
111 | /** |
112 | * aio_notify: Force processing of pending events. | |
113 | * | |
114 | * Similar to signaling a condition variable, aio_notify forces | |
115 | * aio_wait to exit, so that the next call will re-examine pending events. | |
116 | * The caller of aio_notify will usually call aio_wait again very soon, | |
117 | * or go through another iteration of the GLib main loop. Hence, aio_notify | |
118 | * also has the side effect of recalculating the sets of file descriptors | |
119 | * that the main loop waits for. | |
120 | * | |
121 | * Calling aio_notify is rarely necessary, because for example scheduling | |
122 | * a bottom half calls it already. | |
123 | */ | |
124 | void aio_notify(AioContext *ctx); | |
125 | ||
f627aab1 PB |
126 | /** |
127 | * aio_bh_poll: Poll bottom halves for an AioContext. | |
128 | * | |
129 | * These are internal functions used by the QEMU main loop. | |
130 | */ | |
131 | int aio_bh_poll(AioContext *ctx); | |
f627aab1 PB |
132 | |
133 | /** | |
134 | * qemu_bh_schedule: Schedule a bottom half. | |
135 | * | |
136 | * Scheduling a bottom half interrupts the main loop and causes the | |
137 | * execution of the callback that was passed to qemu_bh_new. | |
138 | * | |
139 | * Bottom halves that are scheduled from a bottom half handler are instantly | |
140 | * invoked. This can create an infinite loop if a bottom half handler | |
141 | * schedules itself. | |
142 | * | |
143 | * @bh: The bottom half to be scheduled. | |
144 | */ | |
145 | void qemu_bh_schedule(QEMUBH *bh); | |
146 | ||
147 | /** | |
148 | * qemu_bh_cancel: Cancel execution of a bottom half. | |
149 | * | |
150 | * Canceling execution of a bottom half undoes the effect of calls to | |
151 | * qemu_bh_schedule without freeing its resources yet. While cancellation | |
152 | * itself is also wait-free and thread-safe, it can of course race with the | |
153 | * loop that executes bottom halves unless you are holding the iothread | |
154 | * mutex. This makes it mostly useless if you are not holding the mutex. | |
155 | * | |
156 | * @bh: The bottom half to be canceled. | |
157 | */ | |
158 | void qemu_bh_cancel(QEMUBH *bh); | |
159 | ||
160 | /** | |
161 | *qemu_bh_delete: Cancel execution of a bottom half and free its resources. | |
162 | * | |
163 | * Deleting a bottom half frees the memory that was allocated for it by | |
164 | * qemu_bh_new. It also implies canceling the bottom half if it was | |
165 | * scheduled. | |
166 | * | |
167 | * @bh: The bottom half to be deleted. | |
168 | */ | |
169 | void qemu_bh_delete(QEMUBH *bh); | |
170 | ||
cd9ba1eb PB |
171 | /* Return whether there are any pending callbacks from the GSource |
172 | * attached to the AioContext. | |
173 | * | |
174 | * This is used internally in the implementation of the GSource. | |
175 | */ | |
176 | bool aio_pending(AioContext *ctx); | |
177 | ||
7c0628b2 PB |
178 | /* Progress in completing AIO work to occur. This can issue new pending |
179 | * aio as a result of executing I/O completion or bh callbacks. | |
bcdc1857 | 180 | * |
7c0628b2 | 181 | * If there is no pending AIO operation or completion (bottom half), |
2ea9b58f KW |
182 | * return false. If there are pending AIO operations of bottom halves, |
183 | * return true. | |
7c0628b2 PB |
184 | * |
185 | * If there are no pending bottom halves, but there are pending AIO | |
186 | * operations, it may not be possible to make any progress without | |
187 | * blocking. If @blocking is true, this function will wait until one | |
188 | * or more AIO events have completed, to ensure something has moved | |
189 | * before returning. | |
7c0628b2 PB |
190 | */ |
191 | bool aio_poll(AioContext *ctx, bool blocking); | |
a76bab49 | 192 | |
9958c351 PB |
193 | #ifdef CONFIG_POSIX |
194 | /* Returns 1 if there are still outstanding AIO requests; 0 otherwise */ | |
195 | typedef int (AioFlushHandler)(void *opaque); | |
196 | ||
a76bab49 AL |
197 | /* Register a file descriptor and associated callbacks. Behaves very similarly |
198 | * to qemu_set_fd_handler2. Unlike qemu_set_fd_handler2, these callbacks will | |
c57b6656 | 199 | * be invoked when using qemu_aio_wait(). |
a76bab49 AL |
200 | * |
201 | * Code that invokes AIO completion functions should rely on this function | |
202 | * instead of qemu_set_fd_handler[2]. | |
203 | */ | |
a915f4bc PB |
204 | void aio_set_fd_handler(AioContext *ctx, |
205 | int fd, | |
206 | IOHandler *io_read, | |
207 | IOHandler *io_write, | |
208 | AioFlushHandler *io_flush, | |
209 | void *opaque); | |
9958c351 PB |
210 | #endif |
211 | ||
212 | /* Register an event notifier and associated callbacks. Behaves very similarly | |
213 | * to event_notifier_set_handler. Unlike event_notifier_set_handler, these callbacks | |
c57b6656 | 214 | * will be invoked when using qemu_aio_wait(). |
9958c351 PB |
215 | * |
216 | * Code that invokes AIO completion functions should rely on this function | |
217 | * instead of event_notifier_set_handler. | |
218 | */ | |
a915f4bc PB |
219 | void aio_set_event_notifier(AioContext *ctx, |
220 | EventNotifier *notifier, | |
221 | EventNotifierHandler *io_read, | |
222 | AioFlushEventNotifierHandler *io_flush); | |
223 | ||
e3713e00 PB |
224 | /* Return a GSource that lets the main loop poll the file descriptors attached |
225 | * to this AioContext. | |
226 | */ | |
227 | GSource *aio_get_g_source(AioContext *ctx); | |
228 | ||
9b34277d SH |
229 | /* Return the ThreadPool bound to this AioContext */ |
230 | struct ThreadPool *aio_get_thread_pool(AioContext *ctx); | |
231 | ||
a915f4bc PB |
232 | /* Functions to operate on the main QEMU AioContext. */ |
233 | ||
a915f4bc | 234 | bool qemu_aio_wait(void); |
9958c351 PB |
235 | void qemu_aio_set_event_notifier(EventNotifier *notifier, |
236 | EventNotifierHandler *io_read, | |
237 | AioFlushEventNotifierHandler *io_flush); | |
a76bab49 | 238 | |
a915f4bc PB |
239 | #ifdef CONFIG_POSIX |
240 | void qemu_aio_set_fd_handler(int fd, | |
241 | IOHandler *io_read, | |
242 | IOHandler *io_write, | |
243 | AioFlushHandler *io_flush, | |
244 | void *opaque); | |
245 | #endif | |
246 | ||
a76bab49 | 247 | #endif |