Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[sdk/emulator/qemu.git] / async.c
1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24
25 #include "qemu-common.h"
26 #include "block/aio.h"
27 #include "block/thread-pool.h"
28 #include "qemu/main-loop.h"
29 #include "qemu/atomic.h"
30
31 /***********************************************************/
32 /* bottom halves (can be seen as timers which expire ASAP) */
33
34 struct QEMUBH {
35     AioContext *ctx;
36     QEMUBHFunc *cb;
37     void *opaque;
38     QEMUBH *next;
39     bool scheduled;
40     bool idle;
41     bool deleted;
42 };
43
44 QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
45 {
46     QEMUBH *bh;
47     bh = g_malloc0(sizeof(QEMUBH));
48     bh->ctx = ctx;
49     bh->cb = cb;
50     bh->opaque = opaque;
51     qemu_mutex_lock(&ctx->bh_lock);
52     bh->next = ctx->first_bh;
53     /* Make sure that the members are ready before putting bh into list */
54     smp_wmb();
55     ctx->first_bh = bh;
56     qemu_mutex_unlock(&ctx->bh_lock);
57     return bh;
58 }
59
60 /* Multiple occurrences of aio_bh_poll cannot be called concurrently */
61 int aio_bh_poll(AioContext *ctx)
62 {
63     QEMUBH *bh, **bhp, *next;
64     int ret;
65
66     ctx->walking_bh++;
67
68     ret = 0;
69     for (bh = ctx->first_bh; bh; bh = next) {
70         /* Make sure that fetching bh happens before accessing its members */
71         smp_read_barrier_depends();
72         next = bh->next;
73         if (!bh->deleted && bh->scheduled) {
74             bh->scheduled = 0;
75             /* Paired with write barrier in bh schedule to ensure reading for
76              * idle & callbacks coming after bh's scheduling.
77              */
78             smp_rmb();
79             if (!bh->idle)
80                 ret = 1;
81             bh->idle = 0;
82             bh->cb(bh->opaque);
83         }
84     }
85
86     ctx->walking_bh--;
87
88     /* remove deleted bhs */
89     if (!ctx->walking_bh) {
90         qemu_mutex_lock(&ctx->bh_lock);
91         bhp = &ctx->first_bh;
92         while (*bhp) {
93             bh = *bhp;
94             if (bh->deleted) {
95                 *bhp = bh->next;
96                 g_free(bh);
97             } else {
98                 bhp = &bh->next;
99             }
100         }
101         qemu_mutex_unlock(&ctx->bh_lock);
102     }
103
104     return ret;
105 }
106
107 void qemu_bh_schedule_idle(QEMUBH *bh)
108 {
109     if (bh->scheduled)
110         return;
111     bh->idle = 1;
112     /* Make sure that idle & any writes needed by the callback are done
113      * before the locations are read in the aio_bh_poll.
114      */
115     smp_wmb();
116     bh->scheduled = 1;
117 }
118
119 void qemu_bh_schedule(QEMUBH *bh)
120 {
121     AioContext *ctx;
122
123     if (bh->scheduled)
124         return;
125     ctx = bh->ctx;
126     bh->idle = 0;
127     /* Make sure that:
128      * 1. idle & any writes needed by the callback are done before the
129      *    locations are read in the aio_bh_poll.
130      * 2. ctx is loaded before scheduled is set and the callback has a chance
131      *    to execute.
132      */
133     smp_mb();
134     bh->scheduled = 1;
135     aio_notify(ctx);
136 }
137
138
139 /* This func is async.
140  */
141 void qemu_bh_cancel(QEMUBH *bh)
142 {
143     bh->scheduled = 0;
144 }
145
146 /* This func is async.The bottom half will do the delete action at the finial
147  * end.
148  */
149 void qemu_bh_delete(QEMUBH *bh)
150 {
151     bh->scheduled = 0;
152     bh->deleted = 1;
153 }
154
155 static gboolean
156 aio_ctx_prepare(GSource *source, gint    *timeout)
157 {
158     AioContext *ctx = (AioContext *) source;
159     QEMUBH *bh;
160     int deadline;
161
162     /* We assume there is no timeout already supplied */
163     *timeout = -1;
164     for (bh = ctx->first_bh; bh; bh = bh->next) {
165         if (!bh->deleted && bh->scheduled) {
166             if (bh->idle) {
167                 /* idle bottom halves will be polled at least
168                  * every 10ms */
169                 *timeout = 10;
170             } else {
171                 /* non-idle bottom halves will be executed
172                  * immediately */
173                 *timeout = 0;
174                 return true;
175             }
176         }
177     }
178
179     deadline = qemu_timeout_ns_to_ms(timerlistgroup_deadline_ns(&ctx->tlg));
180     if (deadline == 0) {
181         *timeout = 0;
182         return true;
183     } else {
184         *timeout = qemu_soonest_timeout(*timeout, deadline);
185     }
186
187     return false;
188 }
189
190 static gboolean
191 aio_ctx_check(GSource *source)
192 {
193     AioContext *ctx = (AioContext *) source;
194     QEMUBH *bh;
195
196     for (bh = ctx->first_bh; bh; bh = bh->next) {
197         if (!bh->deleted && bh->scheduled) {
198             return true;
199         }
200     }
201     return aio_pending(ctx) || (timerlistgroup_deadline_ns(&ctx->tlg) == 0);
202 }
203
204 static gboolean
205 aio_ctx_dispatch(GSource     *source,
206                  GSourceFunc  callback,
207                  gpointer     user_data)
208 {
209     AioContext *ctx = (AioContext *) source;
210
211     assert(callback == NULL);
212     aio_poll(ctx, false);
213     return true;
214 }
215
216 static void
217 aio_ctx_finalize(GSource     *source)
218 {
219     AioContext *ctx = (AioContext *) source;
220
221     thread_pool_free(ctx->thread_pool);
222     aio_set_event_notifier(ctx, &ctx->notifier, NULL);
223     event_notifier_cleanup(&ctx->notifier);
224     rfifolock_destroy(&ctx->lock);
225     qemu_mutex_destroy(&ctx->bh_lock);
226     g_array_free(ctx->pollfds, TRUE);
227     timerlistgroup_deinit(&ctx->tlg);
228 }
229
230 static GSourceFuncs aio_source_funcs = {
231     aio_ctx_prepare,
232     aio_ctx_check,
233     aio_ctx_dispatch,
234     aio_ctx_finalize
235 };
236
237 GSource *aio_get_g_source(AioContext *ctx)
238 {
239     g_source_ref(&ctx->source);
240     return &ctx->source;
241 }
242
243 ThreadPool *aio_get_thread_pool(AioContext *ctx)
244 {
245     if (!ctx->thread_pool) {
246         ctx->thread_pool = thread_pool_new(ctx);
247     }
248     return ctx->thread_pool;
249 }
250
251 void aio_set_dispatching(AioContext *ctx, bool dispatching)
252 {
253     ctx->dispatching = dispatching;
254     if (!dispatching) {
255         /* Write ctx->dispatching before reading e.g. bh->scheduled.
256          * Optimization: this is only needed when we're entering the "unsafe"
257          * phase where other threads must call event_notifier_set.
258          */
259         smp_mb();
260     }
261 }
262
263 void aio_notify(AioContext *ctx)
264 {
265     /* Write e.g. bh->scheduled before reading ctx->dispatching.  */
266     smp_mb();
267     if (!ctx->dispatching) {
268         event_notifier_set(&ctx->notifier);
269     }
270 }
271
272 static void aio_timerlist_notify(void *opaque)
273 {
274     aio_notify(opaque);
275 }
276
277 static void aio_rfifolock_cb(void *opaque)
278 {
279     /* Kick owner thread in case they are blocked in aio_poll() */
280     aio_notify(opaque);
281 }
282
283 AioContext *aio_context_new(void)
284 {
285     AioContext *ctx;
286     ctx = (AioContext *) g_source_new(&aio_source_funcs, sizeof(AioContext));
287     ctx->pollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD));
288     ctx->thread_pool = NULL;
289     qemu_mutex_init(&ctx->bh_lock);
290     rfifolock_init(&ctx->lock, aio_rfifolock_cb, ctx);
291     event_notifier_init(&ctx->notifier, false);
292     aio_set_event_notifier(ctx, &ctx->notifier, 
293                            (EventNotifierHandler *)
294                            event_notifier_test_and_clear);
295     timerlistgroup_init(&ctx->tlg, aio_timerlist_notify, ctx);
296
297     return ctx;
298 }
299
300 void aio_context_ref(AioContext *ctx)
301 {
302     g_source_ref(&ctx->source);
303 }
304
305 void aio_context_unref(AioContext *ctx)
306 {
307     g_source_unref(&ctx->source);
308 }
309
310 void aio_context_acquire(AioContext *ctx)
311 {
312     rfifolock_lock(&ctx->lock);
313 }
314
315 void aio_context_release(AioContext *ctx)
316 {
317     rfifolock_unlock(&ctx->lock);
318 }