blob: d2cfb7f52330f3788a45603ce86f5116587f35bc [file] [log] [blame]
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +02001/*
2 * Linux native AIO support.
3 *
4 * Copyright (C) 2009 IBM, Corp.
5 * Copyright (C) 2009 Red Hat, Inc.
6 *
7 * This work is licensed under the terms of the GNU GPL, version 2 or later.
8 * See the COPYING file in the top-level directory.
9 */
Peter Maydell80c71a22016-01-18 18:01:42 +000010#include "qemu/osdep.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010011#include "block/aio.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010012#include "qemu/queue.h"
Kevin Wolf2174f122014-08-06 17:18:07 +020013#include "block/block.h"
Paolo Bonzini9f8540e2012-06-09 10:57:37 +020014#include "block/raw-aio.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010015#include "qemu/event_notifier.h"
Kevin Wolf2174f122014-08-06 17:18:07 +020016#include "qemu/coroutine.h"
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -070017#include "qapi/error.h"
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020018
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020019#include <libaio.h>
20
21/*
22 * Queue size (per-device).
23 *
24 * XXX: eventually we need to communicate this to the guest and/or make it
25 * tunable by the guest. If we get more outstanding requests at a time
26 * than this we will get EAGAIN from io_submit which is communicated to
27 * the guest as an I/O error.
28 */
Wangyong2558cb82020-01-07 06:01:01 +000029#define MAX_EVENTS 1024
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020030
Stefano Garzarellad7ddd0a2021-07-21 11:42:11 +020031/* Maximum number of requests in a batch. (default value) */
32#define DEFAULT_MAX_BATCH 32
33
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020034struct qemu_laiocb {
Kevin Wolf2174f122014-08-06 17:18:07 +020035 Coroutine *co;
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +020036 LinuxAioState *ctx;
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020037 struct iocb iocb;
38 ssize_t ret;
39 size_t nbytes;
Kevin Wolfb161e2e2011-10-13 15:42:52 +020040 QEMUIOVector *qiov;
41 bool is_read;
Paolo Bonzini28b24082014-12-11 14:52:26 +010042 QSIMPLEQ_ENTRY(qemu_laiocb) next;
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020043};
44
Ming Lei1b3abdc2014-07-04 18:04:34 +080045typedef struct {
Ming Lei1b3abdc2014-07-04 18:04:34 +080046 int plugged;
Roman Pen5e1b34a2016-07-13 15:03:24 +020047 unsigned int in_queue;
48 unsigned int in_flight;
Paolo Bonzini43f23762014-12-11 14:52:27 +010049 bool blocked;
Paolo Bonzini28b24082014-12-11 14:52:26 +010050 QSIMPLEQ_HEAD(, qemu_laiocb) pending;
Ming Lei1b3abdc2014-07-04 18:04:34 +080051} LaioQueue;
52
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +020053struct LinuxAioState {
Paolo Bonzini0187f5c2016-07-04 18:33:20 +020054 AioContext *aio_context;
55
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020056 io_context_t ctx;
Paolo Bonzinic90caf22012-02-24 08:39:02 +010057 EventNotifier e;
Ming Lei1b3abdc2014-07-04 18:04:34 +080058
Paolo Bonzini19196312017-02-13 14:52:31 +010059 /* io queue for submit at batch. Protected by AioContext lock. */
Ming Lei1b3abdc2014-07-04 18:04:34 +080060 LaioQueue io_q;
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +010061
Paolo Bonzini19196312017-02-13 14:52:31 +010062 /* I/O completion processing. Only runs in I/O thread. */
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +010063 QEMUBH *completion_bh;
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +010064 int event_idx;
65 int event_max;
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020066};
67
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +020068static void ioq_submit(LinuxAioState *s);
Paolo Bonzini28b24082014-12-11 14:52:26 +010069
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020070static inline ssize_t io_event_ret(struct io_event *ev)
71{
72 return (ssize_t)(((uint64_t)ev->res2 << 32) | ev->res);
73}
74
Kevin Wolfdb0ffc22009-10-22 17:54:41 +020075/*
Julia Suvorova2b02fd82019-06-02 23:17:09 +030076 * Completes an AIO request.
Kevin Wolfdb0ffc22009-10-22 17:54:41 +020077 */
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +020078static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
Kevin Wolfdb0ffc22009-10-22 17:54:41 +020079{
80 int ret;
81
Kevin Wolfdb0ffc22009-10-22 17:54:41 +020082 ret = laiocb->ret;
83 if (ret != -ECANCELED) {
Kevin Wolfb161e2e2011-10-13 15:42:52 +020084 if (ret == laiocb->nbytes) {
Kevin Wolfdb0ffc22009-10-22 17:54:41 +020085 ret = 0;
Kevin Wolfb161e2e2011-10-13 15:42:52 +020086 } else if (ret >= 0) {
87 /* Short reads mean EOF, pad with zeros. */
88 if (laiocb->is_read) {
Michael Tokarev3d9b4922012-03-10 16:54:23 +040089 qemu_iovec_memset(laiocb->qiov, ret, 0,
90 laiocb->qiov->size - ret);
Kevin Wolfb161e2e2011-10-13 15:42:52 +020091 } else {
Denis V. Lunev1c42f142016-06-23 14:37:16 +030092 ret = -ENOSPC;
Kevin Wolfb161e2e2011-10-13 15:42:52 +020093 }
94 }
Kevin Wolfdb0ffc22009-10-22 17:54:41 +020095 }
96
Kevin Wolf2174f122014-08-06 17:18:07 +020097 laiocb->ret = ret;
Julia Suvorova2b02fd82019-06-02 23:17:09 +030098
99 /*
100 * If the coroutine is already entered it must be in ioq_submit() and
101 * will notice laio->ret has been filled in when it eventually runs
102 * later. Coroutines cannot be entered recursively so avoid doing
103 * that!
104 */
105 if (!qemu_coroutine_entered(laiocb->co)) {
106 aio_co_wake(laiocb->co);
Kevin Wolf2174f122014-08-06 17:18:07 +0200107 }
Kevin Wolfdb0ffc22009-10-22 17:54:41 +0200108}
109
Roman Pen9e909a52016-07-19 14:27:41 +0200110/**
111 * aio_ring buffer which is shared between userspace and kernel.
112 *
113 * This copied from linux/fs/aio.c, common header does not exist
114 * but AIO exists for ages so we assume ABI is stable.
115 */
116struct aio_ring {
117 unsigned id; /* kernel internal index number */
118 unsigned nr; /* number of io_events */
119 unsigned head; /* Written to by userland or by kernel. */
120 unsigned tail;
121
122 unsigned magic;
123 unsigned compat_features;
124 unsigned incompat_features;
125 unsigned header_length; /* size of aio_ring */
126
Philippe Mathieu-Daudéf7795e42020-03-04 16:38:15 +0100127 struct io_event io_events[];
Roman Pen9e909a52016-07-19 14:27:41 +0200128};
129
130/**
131 * io_getevents_peek:
132 * @ctx: AIO context
133 * @events: pointer on events array, output value
134
135 * Returns the number of completed events and sets a pointer
136 * on events array. This function does not update the internal
137 * ring buffer, only reads head and tail. When @events has been
138 * processed io_getevents_commit() must be called.
139 */
140static inline unsigned int io_getevents_peek(io_context_t ctx,
141 struct io_event **events)
142{
143 struct aio_ring *ring = (struct aio_ring *)ctx;
144 unsigned int head = ring->head, tail = ring->tail;
145 unsigned int nr;
146
147 nr = tail >= head ? tail - head : ring->nr - head;
148 *events = ring->io_events + head;
149 /* To avoid speculative loads of s->events[i] before observing tail.
150 Paired with smp_wmb() inside linux/fs/aio.c: aio_complete(). */
151 smp_rmb();
152
153 return nr;
154}
155
156/**
157 * io_getevents_commit:
158 * @ctx: AIO context
159 * @nr: the number of events on which head should be advanced
160 *
161 * Advances head of a ring buffer.
162 */
163static inline void io_getevents_commit(io_context_t ctx, unsigned int nr)
164{
165 struct aio_ring *ring = (struct aio_ring *)ctx;
166
167 if (nr) {
168 ring->head = (ring->head + nr) % ring->nr;
169 }
170}
171
172/**
173 * io_getevents_advance_and_peek:
174 * @ctx: AIO context
175 * @events: pointer on events array, output value
176 * @nr: the number of events on which head should be advanced
177 *
178 * Advances head of a ring buffer and returns number of elements left.
179 */
180static inline unsigned int
181io_getevents_advance_and_peek(io_context_t ctx,
182 struct io_event **events,
183 unsigned int nr)
184{
185 io_getevents_commit(ctx, nr);
186 return io_getevents_peek(ctx, events);
187}
188
Roman Pen3407de52016-07-19 14:27:42 +0200189/**
190 * qemu_laio_process_completions:
191 * @s: AIO state
192 *
193 * Fetches completed I/O requests and invokes their callbacks.
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100194 *
195 * The function is somewhat tricky because it supports nested event loops, for
196 * example when a request callback invokes aio_poll(). In order to do this,
Roman Pen3407de52016-07-19 14:27:42 +0200197 * indices are kept in LinuxAioState. Function schedules BH completion so it
198 * can be called again in a nested event loop. When there are no events left
199 * to complete the BH is being canceled.
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100200 */
Roman Pen3407de52016-07-19 14:27:42 +0200201static void qemu_laio_process_completions(LinuxAioState *s)
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100202{
Roman Pen9e909a52016-07-19 14:27:41 +0200203 struct io_event *events;
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100204
205 /* Reschedule so nested event loops see currently pending completions */
206 qemu_bh_schedule(s->completion_bh);
207
Roman Pen9e909a52016-07-19 14:27:41 +0200208 while ((s->event_max = io_getevents_advance_and_peek(s->ctx, &events,
209 s->event_idx))) {
210 for (s->event_idx = 0; s->event_idx < s->event_max; ) {
211 struct iocb *iocb = events[s->event_idx].obj;
212 struct qemu_laiocb *laiocb =
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100213 container_of(iocb, struct qemu_laiocb, iocb);
214
Roman Pen9e909a52016-07-19 14:27:41 +0200215 laiocb->ret = io_event_ret(&events[s->event_idx]);
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100216
Roman Pen9e909a52016-07-19 14:27:41 +0200217 /* Change counters one-by-one because we can be nested. */
218 s->io_q.in_flight--;
219 s->event_idx++;
220 qemu_laio_process_completion(laiocb);
221 }
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100222 }
Paolo Bonzini28b24082014-12-11 14:52:26 +0100223
Roman Pen9e909a52016-07-19 14:27:41 +0200224 qemu_bh_cancel(s->completion_bh);
225
226 /* If we are nested we have to notify the level above that we are done
227 * by setting event_max to zero, upper level will then jump out of it's
228 * own `for` loop. If we are the last all counters droped to zero. */
229 s->event_max = 0;
230 s->event_idx = 0;
Roman Pen3407de52016-07-19 14:27:42 +0200231}
Roman Pen9e909a52016-07-19 14:27:41 +0200232
Roman Pen3407de52016-07-19 14:27:42 +0200233static void qemu_laio_process_completions_and_submit(LinuxAioState *s)
234{
Sergio Lopeze091f0e2018-09-05 13:23:34 +0200235 aio_context_acquire(s->aio_context);
Roman Pen3407de52016-07-19 14:27:42 +0200236 qemu_laio_process_completions(s);
Paolo Bonzini19196312017-02-13 14:52:31 +0100237
Paolo Bonzini28b24082014-12-11 14:52:26 +0100238 if (!s->io_q.plugged && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {
239 ioq_submit(s);
240 }
Paolo Bonzini19196312017-02-13 14:52:31 +0100241 aio_context_release(s->aio_context);
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100242}
243
Roman Pen3407de52016-07-19 14:27:42 +0200244static void qemu_laio_completion_bh(void *opaque)
245{
246 LinuxAioState *s = opaque;
247
248 qemu_laio_process_completions_and_submit(s);
249}
250
Paolo Bonzinic90caf22012-02-24 08:39:02 +0100251static void qemu_laio_completion_cb(EventNotifier *e)
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200252{
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +0200253 LinuxAioState *s = container_of(e, LinuxAioState, e);
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200254
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100255 if (event_notifier_test_and_clear(&s->e)) {
Roman Pen3407de52016-07-19 14:27:42 +0200256 qemu_laio_process_completions_and_submit(s);
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200257 }
258}
259
Stefan Hajnocziee686972016-12-01 19:26:44 +0000260static bool qemu_laio_poll_cb(void *opaque)
261{
262 EventNotifier *e = opaque;
263 LinuxAioState *s = container_of(e, LinuxAioState, e);
264 struct io_event *events;
265
Stefan Hajnoczi826cc322021-12-07 13:23:31 +0000266 return io_getevents_peek(s->ctx, &events);
267}
268
269static void qemu_laio_poll_ready(EventNotifier *opaque)
270{
271 EventNotifier *e = opaque;
272 LinuxAioState *s = container_of(e, LinuxAioState, e);
Stefan Hajnocziee686972016-12-01 19:26:44 +0000273
274 qemu_laio_process_completions_and_submit(s);
Stefan Hajnocziee686972016-12-01 19:26:44 +0000275}
276
Ming Lei1b3abdc2014-07-04 18:04:34 +0800277static void ioq_init(LaioQueue *io_q)
278{
Paolo Bonzini28b24082014-12-11 14:52:26 +0100279 QSIMPLEQ_INIT(&io_q->pending);
Ming Lei1b3abdc2014-07-04 18:04:34 +0800280 io_q->plugged = 0;
Roman Pen5e1b34a2016-07-13 15:03:24 +0200281 io_q->in_queue = 0;
282 io_q->in_flight = 0;
Paolo Bonzini43f23762014-12-11 14:52:27 +0100283 io_q->blocked = false;
Ming Lei1b3abdc2014-07-04 18:04:34 +0800284}
285
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +0200286static void ioq_submit(LinuxAioState *s)
Ming Lei1b3abdc2014-07-04 18:04:34 +0800287{
Paolo Bonzini82595da2014-12-11 14:52:30 +0100288 int ret, len;
Paolo Bonzini28b24082014-12-11 14:52:26 +0100289 struct qemu_laiocb *aiocb;
Roman Pen5e1b34a2016-07-13 15:03:24 +0200290 struct iocb *iocbs[MAX_EVENTS];
Paolo Bonzini82595da2014-12-11 14:52:30 +0100291 QSIMPLEQ_HEAD(, qemu_laiocb) completed;
Ming Lei1b3abdc2014-07-04 18:04:34 +0800292
Paolo Bonzini43f23762014-12-11 14:52:27 +0100293 do {
Roman Pen5e1b34a2016-07-13 15:03:24 +0200294 if (s->io_q.in_flight >= MAX_EVENTS) {
295 break;
296 }
Paolo Bonzini43f23762014-12-11 14:52:27 +0100297 len = 0;
298 QSIMPLEQ_FOREACH(aiocb, &s->io_q.pending, next) {
299 iocbs[len++] = &aiocb->iocb;
Roman Pen5e1b34a2016-07-13 15:03:24 +0200300 if (s->io_q.in_flight + len >= MAX_EVENTS) {
Paolo Bonzini43f23762014-12-11 14:52:27 +0100301 break;
302 }
Paolo Bonzini28b24082014-12-11 14:52:26 +0100303 }
Ming Lei1b3abdc2014-07-04 18:04:34 +0800304
Paolo Bonzini43f23762014-12-11 14:52:27 +0100305 ret = io_submit(s->ctx, len, iocbs);
306 if (ret == -EAGAIN) {
Paolo Bonzini82595da2014-12-11 14:52:30 +0100307 break;
Paolo Bonzini43f23762014-12-11 14:52:27 +0100308 }
309 if (ret < 0) {
Kevin Wolf44713c92016-08-09 13:20:19 +0200310 /* Fail the first request, retry the rest */
311 aiocb = QSIMPLEQ_FIRST(&s->io_q.pending);
312 QSIMPLEQ_REMOVE_HEAD(&s->io_q.pending, next);
313 s->io_q.in_queue--;
314 aiocb->ret = ret;
315 qemu_laio_process_completion(aiocb);
316 continue;
Paolo Bonzini43f23762014-12-11 14:52:27 +0100317 }
Ming Lei1b3abdc2014-07-04 18:04:34 +0800318
Roman Pen5e1b34a2016-07-13 15:03:24 +0200319 s->io_q.in_flight += ret;
320 s->io_q.in_queue -= ret;
Paolo Bonzini82595da2014-12-11 14:52:30 +0100321 aiocb = container_of(iocbs[ret - 1], struct qemu_laiocb, iocb);
322 QSIMPLEQ_SPLIT_AFTER(&s->io_q.pending, aiocb, next, &completed);
Paolo Bonzini43f23762014-12-11 14:52:27 +0100323 } while (ret == len && !QSIMPLEQ_EMPTY(&s->io_q.pending));
Roman Pen5e1b34a2016-07-13 15:03:24 +0200324 s->io_q.blocked = (s->io_q.in_queue > 0);
Roman Pen0ed93d82016-07-19 14:27:43 +0200325
326 if (s->io_q.in_flight) {
327 /* We can try to complete something just right away if there are
328 * still requests in-flight. */
329 qemu_laio_process_completions(s);
330 /*
331 * Even we have completed everything (in_flight == 0), the queue can
332 * have still pended requests (in_queue > 0). We do not attempt to
333 * repeat submission to avoid IO hang. The reason is simple: s->e is
334 * still set and completion callback will be called shortly and all
335 * pended requests will be submitted from there.
336 */
337 }
Ming Lei1b3abdc2014-07-04 18:04:34 +0800338}
339
Stefano Garzarella512da212021-10-26 18:23:45 +0200340static uint64_t laio_max_batch(LinuxAioState *s, uint64_t dev_max_batch)
341{
342 uint64_t max_batch = s->aio_context->aio_max_batch ?: DEFAULT_MAX_BATCH;
343
344 /*
345 * AIO context can be shared between multiple block devices, so
346 * `dev_max_batch` allows reducing the batch size for latency-sensitive
347 * devices.
348 */
349 max_batch = MIN_NON_ZERO(dev_max_batch, max_batch);
350
351 /* limit the batch with the number of available events */
352 max_batch = MIN_NON_ZERO(MAX_EVENTS - s->io_q.in_flight, max_batch);
353
354 return max_batch;
355}
356
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +0200357void laio_io_plug(BlockDriverState *bs, LinuxAioState *s)
Ming Lei1b3abdc2014-07-04 18:04:34 +0800358{
Paolo Bonzini0187f5c2016-07-04 18:33:20 +0200359 s->io_q.plugged++;
Ming Lei1b3abdc2014-07-04 18:04:34 +0800360}
361
Stefano Garzarella68d79462021-10-26 18:23:46 +0200362void laio_io_unplug(BlockDriverState *bs, LinuxAioState *s,
363 uint64_t dev_max_batch)
Ming Lei1b3abdc2014-07-04 18:04:34 +0800364{
Paolo Bonzini6b98bd62016-04-07 18:33:34 +0200365 assert(s->io_q.plugged);
Stefan Hajnoczif387cac2022-06-09 17:47:11 +0100366 s->io_q.plugged--;
367
Stefan Hajnoczi99b969f2022-06-09 17:47:12 +0100368 /*
369 * Why max batch checking is performed here:
370 * Another BDS may have queued requests with a higher dev_max_batch and
371 * therefore in_queue could now exceed our dev_max_batch. Re-check the max
372 * batch so we can honor our device's dev_max_batch.
373 */
Stefano Garzarella68d79462021-10-26 18:23:46 +0200374 if (s->io_q.in_queue >= laio_max_batch(s, dev_max_batch) ||
Stefan Hajnoczif387cac2022-06-09 17:47:11 +0100375 (!s->io_q.plugged &&
Stefano Garzarella68d79462021-10-26 18:23:46 +0200376 !s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending))) {
Paolo Bonzinide354642014-12-11 14:52:29 +0100377 ioq_submit(s);
Ming Lei1b3abdc2014-07-04 18:04:34 +0800378 }
Ming Lei1b3abdc2014-07-04 18:04:34 +0800379}
380
Kevin Wolf2174f122014-08-06 17:18:07 +0200381static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
Stefano Garzarella512da212021-10-26 18:23:45 +0200382 int type, uint64_t dev_max_batch)
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200383{
Kevin Wolf2174f122014-08-06 17:18:07 +0200384 LinuxAioState *s = laiocb->ctx;
385 struct iocb *iocbs = &laiocb->iocb;
386 QEMUIOVector *qiov = laiocb->qiov;
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200387
388 switch (type) {
389 case QEMU_AIO_WRITE:
390 io_prep_pwritev(iocbs, fd, qiov->iov, qiov->niov, offset);
Paolo Bonzini7d374352018-12-13 23:37:37 +0100391 break;
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200392 case QEMU_AIO_READ:
393 io_prep_preadv(iocbs, fd, qiov->iov, qiov->niov, offset);
Paolo Bonzini7d374352018-12-13 23:37:37 +0100394 break;
Frediano Ziglioc30e6242011-08-30 09:46:11 +0200395 /* Currently Linux kernel does not support other operations */
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200396 default:
397 fprintf(stderr, "%s: invalid AIO request type 0x%x.\n",
398 __func__, type);
Kevin Wolf2174f122014-08-06 17:18:07 +0200399 return -EIO;
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200400 }
Paolo Bonzinic90caf22012-02-24 08:39:02 +0100401 io_set_eventfd(&laiocb->iocb, event_notifier_get_fd(&s->e));
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200402
Paolo Bonzini28b24082014-12-11 14:52:26 +0100403 QSIMPLEQ_INSERT_TAIL(&s->io_q.pending, laiocb, next);
Roman Pen5e1b34a2016-07-13 15:03:24 +0200404 s->io_q.in_queue++;
Paolo Bonzini43f23762014-12-11 14:52:27 +0100405 if (!s->io_q.blocked &&
Roman Pen5e1b34a2016-07-13 15:03:24 +0200406 (!s->io_q.plugged ||
Stefano Garzarella512da212021-10-26 18:23:45 +0200407 s->io_q.in_queue >= laio_max_batch(s, dev_max_batch))) {
Paolo Bonzini28b24082014-12-11 14:52:26 +0100408 ioq_submit(s);
Ming Lei1b3abdc2014-07-04 18:04:34 +0800409 }
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200410
Kevin Wolf2174f122014-08-06 17:18:07 +0200411 return 0;
412}
413
414int coroutine_fn laio_co_submit(BlockDriverState *bs, LinuxAioState *s, int fd,
Stefano Garzarella512da212021-10-26 18:23:45 +0200415 uint64_t offset, QEMUIOVector *qiov, int type,
416 uint64_t dev_max_batch)
Kevin Wolf2174f122014-08-06 17:18:07 +0200417{
Kevin Wolf2174f122014-08-06 17:18:07 +0200418 int ret;
Kevin Wolf2174f122014-08-06 17:18:07 +0200419 struct qemu_laiocb laiocb = {
420 .co = qemu_coroutine_self(),
Kevin Wolf9d52aa32016-06-03 17:36:27 +0200421 .nbytes = qiov->size,
Kevin Wolf2174f122014-08-06 17:18:07 +0200422 .ctx = s,
Roman Pen0ed93d82016-07-19 14:27:43 +0200423 .ret = -EINPROGRESS,
Kevin Wolf2174f122014-08-06 17:18:07 +0200424 .is_read = (type == QEMU_AIO_READ),
425 .qiov = qiov,
426 };
427
Stefano Garzarella512da212021-10-26 18:23:45 +0200428 ret = laio_do_submit(fd, &laiocb, offset, type, dev_max_batch);
Kevin Wolf2174f122014-08-06 17:18:07 +0200429 if (ret < 0) {
430 return ret;
431 }
432
Roman Pen0ed93d82016-07-19 14:27:43 +0200433 if (laiocb.ret == -EINPROGRESS) {
434 qemu_coroutine_yield();
435 }
Kevin Wolf2174f122014-08-06 17:18:07 +0200436 return laiocb.ret;
437}
438
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +0200439void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)
Stefan Hajnoczic2f34262014-05-08 16:34:47 +0200440{
Stefan Hajnoczi826cc322021-12-07 13:23:31 +0000441 aio_set_event_notifier(old_context, &s->e, false, NULL, NULL, NULL);
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100442 qemu_bh_delete(s->completion_bh);
Paolo Bonzini19196312017-02-13 14:52:31 +0100443 s->aio_context = NULL;
Stefan Hajnoczic2f34262014-05-08 16:34:47 +0200444}
445
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +0200446void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context)
Stefan Hajnoczic2f34262014-05-08 16:34:47 +0200447{
Paolo Bonzini0187f5c2016-07-04 18:33:20 +0200448 s->aio_context = new_context;
Stefan Hajnoczi2cdff7f2014-08-04 16:56:33 +0100449 s->completion_bh = aio_bh_new(new_context, qemu_laio_completion_bh, s);
Fam Zhengdca21ef2015-10-23 11:08:05 +0800450 aio_set_event_notifier(new_context, &s->e, false,
Stefan Hajnocziee686972016-12-01 19:26:44 +0000451 qemu_laio_completion_cb,
Stefan Hajnoczi826cc322021-12-07 13:23:31 +0000452 qemu_laio_poll_cb,
453 qemu_laio_poll_ready);
Stefan Hajnoczic2f34262014-05-08 16:34:47 +0200454}
455
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -0700456LinuxAioState *laio_init(Error **errp)
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200457{
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -0700458 int rc;
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +0200459 LinuxAioState *s;
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200460
Anthony Liguori7267c092011-08-20 22:09:37 -0500461 s = g_malloc0(sizeof(*s));
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -0700462 rc = event_notifier_init(&s->e, false);
463 if (rc < 0) {
Daniel P. Berrangé7a21bee2022-07-07 17:37:15 +0100464 error_setg_errno(errp, -rc, "failed to initialize event notifier");
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200465 goto out_free_state;
Paolo Bonzinic90caf22012-02-24 08:39:02 +0100466 }
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200467
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -0700468 rc = io_setup(MAX_EVENTS, &s->ctx);
469 if (rc < 0) {
470 error_setg_errno(errp, -rc, "failed to create linux AIO context");
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200471 goto out_close_efd;
Paolo Bonzinic90caf22012-02-24 08:39:02 +0100472 }
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200473
Ming Lei1b3abdc2014-07-04 18:04:34 +0800474 ioq_init(&s->io_q);
475
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200476 return s;
477
478out_close_efd:
Paolo Bonzinic90caf22012-02-24 08:39:02 +0100479 event_notifier_cleanup(&s->e);
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200480out_free_state:
Anthony Liguori7267c092011-08-20 22:09:37 -0500481 g_free(s);
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200482 return NULL;
483}
Stefan Hajnocziabd269b2014-05-08 16:34:48 +0200484
Paolo Bonzinidd7f7ed2016-04-07 18:33:35 +0200485void laio_cleanup(LinuxAioState *s)
Stefan Hajnocziabd269b2014-05-08 16:34:48 +0200486{
Stefan Hajnocziabd269b2014-05-08 16:34:48 +0200487 event_notifier_cleanup(&s->e);
Gongleia1abf402014-07-12 11:43:37 +0800488
489 if (io_destroy(s->ctx) != 0) {
490 fprintf(stderr, "%s: destroy AIO context %p failed\n",
491 __func__, &s->ctx);
492 }
Stefan Hajnocziabd269b2014-05-08 16:34:48 +0200493 g_free(s);
494}