Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 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 | |
Peter Maydell | d38ea87 | 2016-01-29 17:50:05 +0000 | [diff] [blame] | 25 | #include "qemu/osdep.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 26 | #include "qapi/error.h" |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 27 | #include "qemu-common.h" |
Paolo Bonzini | 737e150 | 2012-12-17 18:19:44 +0100 | [diff] [blame] | 28 | #include "block/aio.h" |
Stefan Hajnoczi | 9b34277 | 2013-03-07 13:41:47 +0100 | [diff] [blame] | 29 | #include "block/thread-pool.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 30 | #include "qemu/main-loop.h" |
Paolo Bonzini | 0ceb849 | 2014-07-07 15:18:04 +0200 | [diff] [blame] | 31 | #include "qemu/atomic.h" |
Kevin Wolf | 9a1e948 | 2009-10-22 17:54:38 +0200 | [diff] [blame] | 32 | |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 33 | /***********************************************************/ |
| 34 | /* bottom halves (can be seen as timers which expire ASAP) */ |
| 35 | |
| 36 | struct QEMUBH { |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 37 | AioContext *ctx; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 38 | QEMUBHFunc *cb; |
| 39 | void *opaque; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 40 | QEMUBH *next; |
Stefan Weil | 9b47b17 | 2012-04-29 19:08:45 +0200 | [diff] [blame] | 41 | bool scheduled; |
| 42 | bool idle; |
| 43 | bool deleted; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 44 | }; |
| 45 | |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 46 | QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque) |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 47 | { |
| 48 | QEMUBH *bh; |
Paolo Bonzini | ee82310 | 2014-12-17 16:10:00 +0100 | [diff] [blame] | 49 | bh = g_new(QEMUBH, 1); |
| 50 | *bh = (QEMUBH){ |
| 51 | .ctx = ctx, |
| 52 | .cb = cb, |
| 53 | .opaque = opaque, |
| 54 | }; |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 55 | qemu_mutex_lock(&ctx->bh_lock); |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 56 | bh->next = ctx->first_bh; |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 57 | /* Make sure that the members are ready before putting bh into list */ |
| 58 | smp_wmb(); |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 59 | ctx->first_bh = bh; |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 60 | qemu_mutex_unlock(&ctx->bh_lock); |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 61 | return bh; |
| 62 | } |
| 63 | |
Pavel Dovgalyuk | df281b8 | 2015-09-17 19:24:50 +0300 | [diff] [blame] | 64 | void aio_bh_call(QEMUBH *bh) |
| 65 | { |
| 66 | bh->cb(bh->opaque); |
| 67 | } |
| 68 | |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 69 | /* Multiple occurrences of aio_bh_poll cannot be called concurrently */ |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 70 | int aio_bh_poll(AioContext *ctx) |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 71 | { |
Kevin Wolf | 7887f62 | 2011-06-07 17:51:21 +0200 | [diff] [blame] | 72 | QEMUBH *bh, **bhp, *next; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 73 | int ret; |
Kevin Wolf | 648fb0e | 2011-09-01 16:16:10 +0200 | [diff] [blame] | 74 | |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 75 | ctx->walking_bh++; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 76 | |
| 77 | ret = 0; |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 78 | for (bh = ctx->first_bh; bh; bh = next) { |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 79 | /* Make sure that fetching bh happens before accessing its members */ |
| 80 | smp_read_barrier_depends(); |
Kevin Wolf | 7887f62 | 2011-06-07 17:51:21 +0200 | [diff] [blame] | 81 | next = bh->next; |
Paolo Bonzini | e8d3b1a | 2015-04-07 17:16:19 +0200 | [diff] [blame] | 82 | /* The atomic_xchg is paired with the one in qemu_bh_schedule. The |
| 83 | * implicit memory barrier ensures that the callback sees all writes |
| 84 | * done by the scheduling thread. It also ensures that the scheduling |
| 85 | * thread sees the zero before bh->cb has run, and thus will call |
| 86 | * aio_notify again if necessary. |
| 87 | */ |
| 88 | if (!bh->deleted && atomic_xchg(&bh->scheduled, 0)) { |
Stefan Hajnoczi | ca96ac4 | 2015-07-28 18:34:09 +0200 | [diff] [blame] | 89 | /* Idle BHs and the notify BH don't count as progress */ |
| 90 | if (!bh->idle && bh != ctx->notify_dummy_bh) { |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 91 | ret = 1; |
Stefan Hajnoczi | ca96ac4 | 2015-07-28 18:34:09 +0200 | [diff] [blame] | 92 | } |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 93 | bh->idle = 0; |
Pavel Dovgalyuk | df281b8 | 2015-09-17 19:24:50 +0300 | [diff] [blame] | 94 | aio_bh_call(bh); |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 95 | } |
| 96 | } |
| 97 | |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 98 | ctx->walking_bh--; |
Kevin Wolf | 648fb0e | 2011-09-01 16:16:10 +0200 | [diff] [blame] | 99 | |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 100 | /* remove deleted bhs */ |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 101 | if (!ctx->walking_bh) { |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 102 | qemu_mutex_lock(&ctx->bh_lock); |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 103 | bhp = &ctx->first_bh; |
Kevin Wolf | 648fb0e | 2011-09-01 16:16:10 +0200 | [diff] [blame] | 104 | while (*bhp) { |
| 105 | bh = *bhp; |
| 106 | if (bh->deleted) { |
| 107 | *bhp = bh->next; |
| 108 | g_free(bh); |
| 109 | } else { |
| 110 | bhp = &bh->next; |
| 111 | } |
| 112 | } |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 113 | qemu_mutex_unlock(&ctx->bh_lock); |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | return ret; |
| 117 | } |
| 118 | |
| 119 | void qemu_bh_schedule_idle(QEMUBH *bh) |
| 120 | { |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 121 | bh->idle = 1; |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 122 | /* Make sure that idle & any writes needed by the callback are done |
| 123 | * before the locations are read in the aio_bh_poll. |
| 124 | */ |
Paolo Bonzini | e8d3b1a | 2015-04-07 17:16:19 +0200 | [diff] [blame] | 125 | atomic_mb_set(&bh->scheduled, 1); |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | void qemu_bh_schedule(QEMUBH *bh) |
| 129 | { |
Stefan Hajnoczi | 924fe12 | 2014-06-03 11:21:01 +0200 | [diff] [blame] | 130 | AioContext *ctx; |
| 131 | |
Stefan Hajnoczi | 924fe12 | 2014-06-03 11:21:01 +0200 | [diff] [blame] | 132 | ctx = bh->ctx; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 133 | bh->idle = 0; |
Paolo Bonzini | e8d3b1a | 2015-04-07 17:16:19 +0200 | [diff] [blame] | 134 | /* The memory barrier implicit in atomic_xchg makes sure that: |
Stefan Hajnoczi | 924fe12 | 2014-06-03 11:21:01 +0200 | [diff] [blame] | 135 | * 1. idle & any writes needed by the callback are done before the |
| 136 | * locations are read in the aio_bh_poll. |
| 137 | * 2. ctx is loaded before scheduled is set and the callback has a chance |
| 138 | * to execute. |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 139 | */ |
Paolo Bonzini | e8d3b1a | 2015-04-07 17:16:19 +0200 | [diff] [blame] | 140 | if (atomic_xchg(&bh->scheduled, 1) == 0) { |
| 141 | aio_notify(ctx); |
| 142 | } |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 143 | } |
| 144 | |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 145 | |
| 146 | /* This func is async. |
| 147 | */ |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 148 | void qemu_bh_cancel(QEMUBH *bh) |
| 149 | { |
| 150 | bh->scheduled = 0; |
| 151 | } |
| 152 | |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 153 | /* This func is async.The bottom half will do the delete action at the finial |
| 154 | * end. |
| 155 | */ |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 156 | void qemu_bh_delete(QEMUBH *bh) |
| 157 | { |
| 158 | bh->scheduled = 0; |
| 159 | bh->deleted = 1; |
| 160 | } |
| 161 | |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 162 | int64_t |
| 163 | aio_compute_timeout(AioContext *ctx) |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 164 | { |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 165 | int64_t deadline; |
| 166 | int timeout = -1; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 167 | QEMUBH *bh; |
| 168 | |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 169 | for (bh = ctx->first_bh; bh; bh = bh->next) { |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 170 | if (!bh->deleted && bh->scheduled) { |
| 171 | if (bh->idle) { |
| 172 | /* idle bottom halves will be polled at least |
| 173 | * every 10ms */ |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 174 | timeout = 10000000; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 175 | } else { |
| 176 | /* non-idle bottom halves will be executed |
| 177 | * immediately */ |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 178 | return 0; |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 179 | } |
| 180 | } |
| 181 | } |
Kevin Wolf | 4f999d0 | 2009-10-22 17:54:37 +0200 | [diff] [blame] | 182 | |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 183 | deadline = timerlistgroup_deadline_ns(&ctx->tlg); |
Alex Bligh | 533a8cf | 2013-08-21 16:02:51 +0100 | [diff] [blame] | 184 | if (deadline == 0) { |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 185 | return 0; |
Alex Bligh | 533a8cf | 2013-08-21 16:02:51 +0100 | [diff] [blame] | 186 | } else { |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 187 | return qemu_soonest_timeout(timeout, deadline); |
Alex Bligh | 533a8cf | 2013-08-21 16:02:51 +0100 | [diff] [blame] | 188 | } |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 189 | } |
Alex Bligh | 533a8cf | 2013-08-21 16:02:51 +0100 | [diff] [blame] | 190 | |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 191 | static gboolean |
| 192 | aio_ctx_prepare(GSource *source, gint *timeout) |
| 193 | { |
| 194 | AioContext *ctx = (AioContext *) source; |
| 195 | |
Paolo Bonzini | eabc977 | 2015-07-21 16:07:51 +0200 | [diff] [blame] | 196 | atomic_or(&ctx->notify_me, 1); |
| 197 | |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 198 | /* We assume there is no timeout already supplied */ |
| 199 | *timeout = qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)); |
Paolo Bonzini | a3462c6 | 2014-07-09 11:53:08 +0200 | [diff] [blame] | 200 | |
| 201 | if (aio_prepare(ctx)) { |
| 202 | *timeout = 0; |
| 203 | } |
| 204 | |
Paolo Bonzini | 845ca10 | 2014-07-09 11:53:01 +0200 | [diff] [blame] | 205 | return *timeout == 0; |
Paolo Bonzini | e3713e0 | 2012-09-24 14:57:41 +0200 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | static gboolean |
| 209 | aio_ctx_check(GSource *source) |
| 210 | { |
| 211 | AioContext *ctx = (AioContext *) source; |
| 212 | QEMUBH *bh; |
| 213 | |
Paolo Bonzini | eabc977 | 2015-07-21 16:07:51 +0200 | [diff] [blame] | 214 | atomic_and(&ctx->notify_me, ~1); |
Paolo Bonzini | 05e514b | 2015-07-21 16:07:53 +0200 | [diff] [blame] | 215 | aio_notify_accept(ctx); |
Paolo Bonzini | 21a03d1 | 2015-07-21 16:07:52 +0200 | [diff] [blame] | 216 | |
Paolo Bonzini | e3713e0 | 2012-09-24 14:57:41 +0200 | [diff] [blame] | 217 | for (bh = ctx->first_bh; bh; bh = bh->next) { |
| 218 | if (!bh->deleted && bh->scheduled) { |
| 219 | return true; |
| 220 | } |
| 221 | } |
Alex Bligh | 533a8cf | 2013-08-21 16:02:51 +0100 | [diff] [blame] | 222 | return aio_pending(ctx) || (timerlistgroup_deadline_ns(&ctx->tlg) == 0); |
Paolo Bonzini | e3713e0 | 2012-09-24 14:57:41 +0200 | [diff] [blame] | 223 | } |
| 224 | |
| 225 | static gboolean |
| 226 | aio_ctx_dispatch(GSource *source, |
| 227 | GSourceFunc callback, |
| 228 | gpointer user_data) |
| 229 | { |
| 230 | AioContext *ctx = (AioContext *) source; |
| 231 | |
| 232 | assert(callback == NULL); |
Paolo Bonzini | e4c7e2d | 2014-07-09 11:53:05 +0200 | [diff] [blame] | 233 | aio_dispatch(ctx); |
Paolo Bonzini | e3713e0 | 2012-09-24 14:57:41 +0200 | [diff] [blame] | 234 | return true; |
| 235 | } |
| 236 | |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 237 | static void |
| 238 | aio_ctx_finalize(GSource *source) |
| 239 | { |
| 240 | AioContext *ctx = (AioContext *) source; |
| 241 | |
Stefan Hajnoczi | ca96ac4 | 2015-07-28 18:34:09 +0200 | [diff] [blame] | 242 | qemu_bh_delete(ctx->notify_dummy_bh); |
Stefan Hajnoczi | 9b34277 | 2013-03-07 13:41:47 +0100 | [diff] [blame] | 243 | thread_pool_free(ctx->thread_pool); |
Stefan Hajnoczi | a076972 | 2015-07-28 18:34:08 +0200 | [diff] [blame] | 244 | |
| 245 | qemu_mutex_lock(&ctx->bh_lock); |
| 246 | while (ctx->first_bh) { |
| 247 | QEMUBH *next = ctx->first_bh->next; |
| 248 | |
| 249 | /* qemu_bh_delete() must have been called on BHs in this AioContext */ |
| 250 | assert(ctx->first_bh->deleted); |
| 251 | |
| 252 | g_free(ctx->first_bh); |
| 253 | ctx->first_bh = next; |
| 254 | } |
| 255 | qemu_mutex_unlock(&ctx->bh_lock); |
| 256 | |
Fam Zheng | dca21ef | 2015-10-23 11:08:05 +0800 | [diff] [blame] | 257 | aio_set_event_notifier(ctx, &ctx->notifier, false, NULL); |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 258 | event_notifier_cleanup(&ctx->notifier); |
Stefan Hajnoczi | 98563fc | 2014-03-03 11:30:04 +0100 | [diff] [blame] | 259 | rfifolock_destroy(&ctx->lock); |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 260 | qemu_mutex_destroy(&ctx->bh_lock); |
Alex Bligh | dae21b9 | 2013-08-21 16:02:49 +0100 | [diff] [blame] | 261 | timerlistgroup_deinit(&ctx->tlg); |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 262 | } |
| 263 | |
Paolo Bonzini | e3713e0 | 2012-09-24 14:57:41 +0200 | [diff] [blame] | 264 | static GSourceFuncs aio_source_funcs = { |
| 265 | aio_ctx_prepare, |
| 266 | aio_ctx_check, |
| 267 | aio_ctx_dispatch, |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 268 | aio_ctx_finalize |
Paolo Bonzini | e3713e0 | 2012-09-24 14:57:41 +0200 | [diff] [blame] | 269 | }; |
| 270 | |
| 271 | GSource *aio_get_g_source(AioContext *ctx) |
| 272 | { |
| 273 | g_source_ref(&ctx->source); |
| 274 | return &ctx->source; |
| 275 | } |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 276 | |
Stefan Hajnoczi | 9b34277 | 2013-03-07 13:41:47 +0100 | [diff] [blame] | 277 | ThreadPool *aio_get_thread_pool(AioContext *ctx) |
| 278 | { |
| 279 | if (!ctx->thread_pool) { |
| 280 | ctx->thread_pool = thread_pool_new(ctx); |
| 281 | } |
| 282 | return ctx->thread_pool; |
| 283 | } |
| 284 | |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 285 | void aio_notify(AioContext *ctx) |
| 286 | { |
Paolo Bonzini | eabc977 | 2015-07-21 16:07:51 +0200 | [diff] [blame] | 287 | /* Write e.g. bh->scheduled before reading ctx->notify_me. Pairs |
| 288 | * with atomic_or in aio_ctx_prepare or atomic_add in aio_poll. |
| 289 | */ |
Paolo Bonzini | 0ceb849 | 2014-07-07 15:18:04 +0200 | [diff] [blame] | 290 | smp_mb(); |
Paolo Bonzini | eabc977 | 2015-07-21 16:07:51 +0200 | [diff] [blame] | 291 | if (ctx->notify_me) { |
Paolo Bonzini | 0ceb849 | 2014-07-07 15:18:04 +0200 | [diff] [blame] | 292 | event_notifier_set(&ctx->notifier); |
Paolo Bonzini | 05e514b | 2015-07-21 16:07:53 +0200 | [diff] [blame] | 293 | atomic_mb_set(&ctx->notified, true); |
| 294 | } |
| 295 | } |
| 296 | |
| 297 | void aio_notify_accept(AioContext *ctx) |
| 298 | { |
| 299 | if (atomic_xchg(&ctx->notified, false)) { |
| 300 | event_notifier_test_and_clear(&ctx->notifier); |
Paolo Bonzini | 0ceb849 | 2014-07-07 15:18:04 +0200 | [diff] [blame] | 301 | } |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 302 | } |
| 303 | |
Alex Bligh | d5541d8 | 2013-08-21 16:02:50 +0100 | [diff] [blame] | 304 | static void aio_timerlist_notify(void *opaque) |
| 305 | { |
| 306 | aio_notify(opaque); |
| 307 | } |
| 308 | |
Stefan Hajnoczi | da5e1de | 2015-06-03 10:15:33 +0100 | [diff] [blame] | 309 | static void aio_rfifolock_cb(void *opaque) |
| 310 | { |
Stefan Hajnoczi | ca96ac4 | 2015-07-28 18:34:09 +0200 | [diff] [blame] | 311 | AioContext *ctx = opaque; |
| 312 | |
Stefan Hajnoczi | da5e1de | 2015-06-03 10:15:33 +0100 | [diff] [blame] | 313 | /* Kick owner thread in case they are blocked in aio_poll() */ |
Stefan Hajnoczi | ca96ac4 | 2015-07-28 18:34:09 +0200 | [diff] [blame] | 314 | qemu_bh_schedule(ctx->notify_dummy_bh); |
| 315 | } |
| 316 | |
| 317 | static void notify_dummy_bh(void *opaque) |
| 318 | { |
| 319 | /* Do nothing, we were invoked just to force the event loop to iterate */ |
Stefan Hajnoczi | da5e1de | 2015-06-03 10:15:33 +0100 | [diff] [blame] | 320 | } |
| 321 | |
Paolo Bonzini | 21a03d1 | 2015-07-21 16:07:52 +0200 | [diff] [blame] | 322 | static void event_notifier_dummy_cb(EventNotifier *e) |
| 323 | { |
| 324 | } |
| 325 | |
Chrysostomos Nanakos | 2f78e49 | 2014-09-18 14:30:49 +0300 | [diff] [blame] | 326 | AioContext *aio_context_new(Error **errp) |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 327 | { |
Chrysostomos Nanakos | 2f78e49 | 2014-09-18 14:30:49 +0300 | [diff] [blame] | 328 | int ret; |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 329 | AioContext *ctx; |
Fam Zheng | 37fcee5 | 2015-10-30 12:06:28 +0800 | [diff] [blame] | 330 | Error *local_err = NULL; |
| 331 | |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 332 | ctx = (AioContext *) g_source_new(&aio_source_funcs, sizeof(AioContext)); |
Fam Zheng | 37fcee5 | 2015-10-30 12:06:28 +0800 | [diff] [blame] | 333 | aio_context_setup(ctx, &local_err); |
| 334 | if (local_err) { |
| 335 | error_propagate(errp, local_err); |
| 336 | goto fail; |
| 337 | } |
Chrysostomos Nanakos | 2f78e49 | 2014-09-18 14:30:49 +0300 | [diff] [blame] | 338 | ret = event_notifier_init(&ctx->notifier, false); |
| 339 | if (ret < 0) { |
Chrysostomos Nanakos | 2f78e49 | 2014-09-18 14:30:49 +0300 | [diff] [blame] | 340 | error_setg_errno(errp, -ret, "Failed to initialize event notifier"); |
Fam Zheng | 37fcee5 | 2015-10-30 12:06:28 +0800 | [diff] [blame] | 341 | goto fail; |
Chrysostomos Nanakos | 2f78e49 | 2014-09-18 14:30:49 +0300 | [diff] [blame] | 342 | } |
Paolo Bonzini | fcf5def | 2014-12-17 16:09:58 +0100 | [diff] [blame] | 343 | g_source_set_can_recurse(&ctx->source, true); |
Chrysostomos Nanakos | 2f78e49 | 2014-09-18 14:30:49 +0300 | [diff] [blame] | 344 | aio_set_event_notifier(ctx, &ctx->notifier, |
Fam Zheng | dca21ef | 2015-10-23 11:08:05 +0800 | [diff] [blame] | 345 | false, |
Chrysostomos Nanakos | 2f78e49 | 2014-09-18 14:30:49 +0300 | [diff] [blame] | 346 | (EventNotifierHandler *) |
Paolo Bonzini | 21a03d1 | 2015-07-21 16:07:52 +0200 | [diff] [blame] | 347 | event_notifier_dummy_cb); |
Stefan Hajnoczi | 9b34277 | 2013-03-07 13:41:47 +0100 | [diff] [blame] | 348 | ctx->thread_pool = NULL; |
Liu Ping Fan | dcc772e | 2013-07-16 12:28:58 +0800 | [diff] [blame] | 349 | qemu_mutex_init(&ctx->bh_lock); |
Stefan Hajnoczi | da5e1de | 2015-06-03 10:15:33 +0100 | [diff] [blame] | 350 | rfifolock_init(&ctx->lock, aio_rfifolock_cb, ctx); |
Alex Bligh | d5541d8 | 2013-08-21 16:02:50 +0100 | [diff] [blame] | 351 | timerlistgroup_init(&ctx->tlg, aio_timerlist_notify, ctx); |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 352 | |
Stefan Hajnoczi | ca96ac4 | 2015-07-28 18:34:09 +0200 | [diff] [blame] | 353 | ctx->notify_dummy_bh = aio_bh_new(ctx, notify_dummy_bh, NULL); |
| 354 | |
Paolo Bonzini | 2f4dc3c | 2012-09-24 18:44:14 +0200 | [diff] [blame] | 355 | return ctx; |
Fam Zheng | 37fcee5 | 2015-10-30 12:06:28 +0800 | [diff] [blame] | 356 | fail: |
| 357 | g_source_destroy(&ctx->source); |
| 358 | return NULL; |
Paolo Bonzini | e3713e0 | 2012-09-24 14:57:41 +0200 | [diff] [blame] | 359 | } |
| 360 | |
| 361 | void aio_context_ref(AioContext *ctx) |
| 362 | { |
| 363 | g_source_ref(&ctx->source); |
| 364 | } |
| 365 | |
| 366 | void aio_context_unref(AioContext *ctx) |
| 367 | { |
| 368 | g_source_unref(&ctx->source); |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 369 | } |
Stefan Hajnoczi | 98563fc | 2014-03-03 11:30:04 +0100 | [diff] [blame] | 370 | |
| 371 | void aio_context_acquire(AioContext *ctx) |
| 372 | { |
| 373 | rfifolock_lock(&ctx->lock); |
| 374 | } |
| 375 | |
| 376 | void aio_context_release(AioContext *ctx) |
| 377 | { |
| 378 | rfifolock_unlock(&ctx->lock); |
| 379 | } |