xref: /qemu/block/io.c (revision d01c07f2221ca39ab2dd9e55932d99db98103b30)
161007b31SStefan Hajnoczi /*
261007b31SStefan Hajnoczi  * Block layer I/O functions
361007b31SStefan Hajnoczi  *
461007b31SStefan Hajnoczi  * Copyright (c) 2003 Fabrice Bellard
561007b31SStefan Hajnoczi  *
661007b31SStefan Hajnoczi  * Permission is hereby granted, free of charge, to any person obtaining a copy
761007b31SStefan Hajnoczi  * of this software and associated documentation files (the "Software"), to deal
861007b31SStefan Hajnoczi  * in the Software without restriction, including without limitation the rights
961007b31SStefan Hajnoczi  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
1061007b31SStefan Hajnoczi  * copies of the Software, and to permit persons to whom the Software is
1161007b31SStefan Hajnoczi  * furnished to do so, subject to the following conditions:
1261007b31SStefan Hajnoczi  *
1361007b31SStefan Hajnoczi  * The above copyright notice and this permission notice shall be included in
1461007b31SStefan Hajnoczi  * all copies or substantial portions of the Software.
1561007b31SStefan Hajnoczi  *
1661007b31SStefan Hajnoczi  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1761007b31SStefan Hajnoczi  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1861007b31SStefan Hajnoczi  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
1961007b31SStefan Hajnoczi  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
2061007b31SStefan Hajnoczi  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
2161007b31SStefan Hajnoczi  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
2261007b31SStefan Hajnoczi  * THE SOFTWARE.
2361007b31SStefan Hajnoczi  */
2461007b31SStefan Hajnoczi 
2561007b31SStefan Hajnoczi #include "trace.h"
2661007b31SStefan Hajnoczi #include "sysemu/qtest.h"
2761007b31SStefan Hajnoczi #include "block/blockjob.h"
2861007b31SStefan Hajnoczi #include "block/block_int.h"
2961007b31SStefan Hajnoczi 
3061007b31SStefan Hajnoczi #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
3161007b31SStefan Hajnoczi 
3261007b31SStefan Hajnoczi static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3361007b31SStefan Hajnoczi         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3461007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque);
3561007b31SStefan Hajnoczi static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3661007b31SStefan Hajnoczi         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3761007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque);
3861007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
3961007b31SStefan Hajnoczi                                          int64_t sector_num, int nb_sectors,
4061007b31SStefan Hajnoczi                                          QEMUIOVector *iov);
4161007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4261007b31SStefan Hajnoczi                                          int64_t sector_num, int nb_sectors,
4361007b31SStefan Hajnoczi                                          QEMUIOVector *iov);
4461007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
4561007b31SStefan Hajnoczi     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
4661007b31SStefan Hajnoczi     BdrvRequestFlags flags);
4761007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
4861007b31SStefan Hajnoczi     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
4961007b31SStefan Hajnoczi     BdrvRequestFlags flags);
5061007b31SStefan Hajnoczi static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
5161007b31SStefan Hajnoczi                                          int64_t sector_num,
5261007b31SStefan Hajnoczi                                          QEMUIOVector *qiov,
5361007b31SStefan Hajnoczi                                          int nb_sectors,
5461007b31SStefan Hajnoczi                                          BdrvRequestFlags flags,
5561007b31SStefan Hajnoczi                                          BlockCompletionFunc *cb,
5661007b31SStefan Hajnoczi                                          void *opaque,
5761007b31SStefan Hajnoczi                                          bool is_write);
5861007b31SStefan Hajnoczi static void coroutine_fn bdrv_co_do_rw(void *opaque);
5961007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
6061007b31SStefan Hajnoczi     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
6161007b31SStefan Hajnoczi 
6261007b31SStefan Hajnoczi /* throttling disk I/O limits */
6361007b31SStefan Hajnoczi void bdrv_set_io_limits(BlockDriverState *bs,
6461007b31SStefan Hajnoczi                         ThrottleConfig *cfg)
6561007b31SStefan Hajnoczi {
6661007b31SStefan Hajnoczi     int i;
6761007b31SStefan Hajnoczi 
6861007b31SStefan Hajnoczi     throttle_config(&bs->throttle_state, cfg);
6961007b31SStefan Hajnoczi 
7061007b31SStefan Hajnoczi     for (i = 0; i < 2; i++) {
7161007b31SStefan Hajnoczi         qemu_co_enter_next(&bs->throttled_reqs[i]);
7261007b31SStefan Hajnoczi     }
7361007b31SStefan Hajnoczi }
7461007b31SStefan Hajnoczi 
7561007b31SStefan Hajnoczi /* this function drain all the throttled IOs */
7661007b31SStefan Hajnoczi static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
7761007b31SStefan Hajnoczi {
7861007b31SStefan Hajnoczi     bool drained = false;
7961007b31SStefan Hajnoczi     bool enabled = bs->io_limits_enabled;
8061007b31SStefan Hajnoczi     int i;
8161007b31SStefan Hajnoczi 
8261007b31SStefan Hajnoczi     bs->io_limits_enabled = false;
8361007b31SStefan Hajnoczi 
8461007b31SStefan Hajnoczi     for (i = 0; i < 2; i++) {
8561007b31SStefan Hajnoczi         while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
8661007b31SStefan Hajnoczi             drained = true;
8761007b31SStefan Hajnoczi         }
8861007b31SStefan Hajnoczi     }
8961007b31SStefan Hajnoczi 
9061007b31SStefan Hajnoczi     bs->io_limits_enabled = enabled;
9161007b31SStefan Hajnoczi 
9261007b31SStefan Hajnoczi     return drained;
9361007b31SStefan Hajnoczi }
9461007b31SStefan Hajnoczi 
9561007b31SStefan Hajnoczi void bdrv_io_limits_disable(BlockDriverState *bs)
9661007b31SStefan Hajnoczi {
9761007b31SStefan Hajnoczi     bs->io_limits_enabled = false;
9861007b31SStefan Hajnoczi 
9961007b31SStefan Hajnoczi     bdrv_start_throttled_reqs(bs);
10061007b31SStefan Hajnoczi 
10161007b31SStefan Hajnoczi     throttle_destroy(&bs->throttle_state);
10261007b31SStefan Hajnoczi }
10361007b31SStefan Hajnoczi 
10461007b31SStefan Hajnoczi static void bdrv_throttle_read_timer_cb(void *opaque)
10561007b31SStefan Hajnoczi {
10661007b31SStefan Hajnoczi     BlockDriverState *bs = opaque;
10761007b31SStefan Hajnoczi     qemu_co_enter_next(&bs->throttled_reqs[0]);
10861007b31SStefan Hajnoczi }
10961007b31SStefan Hajnoczi 
11061007b31SStefan Hajnoczi static void bdrv_throttle_write_timer_cb(void *opaque)
11161007b31SStefan Hajnoczi {
11261007b31SStefan Hajnoczi     BlockDriverState *bs = opaque;
11361007b31SStefan Hajnoczi     qemu_co_enter_next(&bs->throttled_reqs[1]);
11461007b31SStefan Hajnoczi }
11561007b31SStefan Hajnoczi 
11661007b31SStefan Hajnoczi /* should be called before bdrv_set_io_limits if a limit is set */
11761007b31SStefan Hajnoczi void bdrv_io_limits_enable(BlockDriverState *bs)
11861007b31SStefan Hajnoczi {
11961007b31SStefan Hajnoczi     int clock_type = QEMU_CLOCK_REALTIME;
12061007b31SStefan Hajnoczi 
12161007b31SStefan Hajnoczi     if (qtest_enabled()) {
12261007b31SStefan Hajnoczi         /* For testing block IO throttling only */
12361007b31SStefan Hajnoczi         clock_type = QEMU_CLOCK_VIRTUAL;
12461007b31SStefan Hajnoczi     }
12561007b31SStefan Hajnoczi     assert(!bs->io_limits_enabled);
12661007b31SStefan Hajnoczi     throttle_init(&bs->throttle_state,
12761007b31SStefan Hajnoczi                   bdrv_get_aio_context(bs),
12861007b31SStefan Hajnoczi                   clock_type,
12961007b31SStefan Hajnoczi                   bdrv_throttle_read_timer_cb,
13061007b31SStefan Hajnoczi                   bdrv_throttle_write_timer_cb,
13161007b31SStefan Hajnoczi                   bs);
13261007b31SStefan Hajnoczi     bs->io_limits_enabled = true;
13361007b31SStefan Hajnoczi }
13461007b31SStefan Hajnoczi 
13561007b31SStefan Hajnoczi /* This function makes an IO wait if needed
13661007b31SStefan Hajnoczi  *
13761007b31SStefan Hajnoczi  * @nb_sectors: the number of sectors of the IO
13861007b31SStefan Hajnoczi  * @is_write:   is the IO a write
13961007b31SStefan Hajnoczi  */
14061007b31SStefan Hajnoczi static void bdrv_io_limits_intercept(BlockDriverState *bs,
14161007b31SStefan Hajnoczi                                      unsigned int bytes,
14261007b31SStefan Hajnoczi                                      bool is_write)
14361007b31SStefan Hajnoczi {
14461007b31SStefan Hajnoczi     /* does this io must wait */
14561007b31SStefan Hajnoczi     bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
14661007b31SStefan Hajnoczi 
14761007b31SStefan Hajnoczi     /* if must wait or any request of this type throttled queue the IO */
14861007b31SStefan Hajnoczi     if (must_wait ||
14961007b31SStefan Hajnoczi         !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
15061007b31SStefan Hajnoczi         qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
15161007b31SStefan Hajnoczi     }
15261007b31SStefan Hajnoczi 
15361007b31SStefan Hajnoczi     /* the IO will be executed, do the accounting */
15461007b31SStefan Hajnoczi     throttle_account(&bs->throttle_state, is_write, bytes);
15561007b31SStefan Hajnoczi 
15661007b31SStefan Hajnoczi 
15761007b31SStefan Hajnoczi     /* if the next request must wait -> do nothing */
15861007b31SStefan Hajnoczi     if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
15961007b31SStefan Hajnoczi         return;
16061007b31SStefan Hajnoczi     }
16161007b31SStefan Hajnoczi 
16261007b31SStefan Hajnoczi     /* else queue next request for execution */
16361007b31SStefan Hajnoczi     qemu_co_queue_next(&bs->throttled_reqs[is_write]);
16461007b31SStefan Hajnoczi }
16561007b31SStefan Hajnoczi 
16661007b31SStefan Hajnoczi void bdrv_setup_io_funcs(BlockDriver *bdrv)
16761007b31SStefan Hajnoczi {
16861007b31SStefan Hajnoczi     /* Block drivers without coroutine functions need emulation */
16961007b31SStefan Hajnoczi     if (!bdrv->bdrv_co_readv) {
17061007b31SStefan Hajnoczi         bdrv->bdrv_co_readv = bdrv_co_readv_em;
17161007b31SStefan Hajnoczi         bdrv->bdrv_co_writev = bdrv_co_writev_em;
17261007b31SStefan Hajnoczi 
17361007b31SStefan Hajnoczi         /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
17461007b31SStefan Hajnoczi          * the block driver lacks aio we need to emulate that too.
17561007b31SStefan Hajnoczi          */
17661007b31SStefan Hajnoczi         if (!bdrv->bdrv_aio_readv) {
17761007b31SStefan Hajnoczi             /* add AIO emulation layer */
17861007b31SStefan Hajnoczi             bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
17961007b31SStefan Hajnoczi             bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
18061007b31SStefan Hajnoczi         }
18161007b31SStefan Hajnoczi     }
18261007b31SStefan Hajnoczi }
18361007b31SStefan Hajnoczi 
18461007b31SStefan Hajnoczi void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
18561007b31SStefan Hajnoczi {
18661007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
18761007b31SStefan Hajnoczi     Error *local_err = NULL;
18861007b31SStefan Hajnoczi 
18961007b31SStefan Hajnoczi     memset(&bs->bl, 0, sizeof(bs->bl));
19061007b31SStefan Hajnoczi 
19161007b31SStefan Hajnoczi     if (!drv) {
19261007b31SStefan Hajnoczi         return;
19361007b31SStefan Hajnoczi     }
19461007b31SStefan Hajnoczi 
19561007b31SStefan Hajnoczi     /* Take some limits from the children as a default */
19661007b31SStefan Hajnoczi     if (bs->file) {
19761007b31SStefan Hajnoczi         bdrv_refresh_limits(bs->file, &local_err);
19861007b31SStefan Hajnoczi         if (local_err) {
19961007b31SStefan Hajnoczi             error_propagate(errp, local_err);
20061007b31SStefan Hajnoczi             return;
20161007b31SStefan Hajnoczi         }
20261007b31SStefan Hajnoczi         bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
20361007b31SStefan Hajnoczi         bs->bl.max_transfer_length = bs->file->bl.max_transfer_length;
2044196d2f0SDenis V. Lunev         bs->bl.min_mem_alignment = bs->file->bl.min_mem_alignment;
20561007b31SStefan Hajnoczi         bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
20661007b31SStefan Hajnoczi     } else {
2074196d2f0SDenis V. Lunev         bs->bl.min_mem_alignment = 512;
208459b4e66SDenis V. Lunev         bs->bl.opt_mem_alignment = getpagesize();
20961007b31SStefan Hajnoczi     }
21061007b31SStefan Hajnoczi 
21161007b31SStefan Hajnoczi     if (bs->backing_hd) {
21261007b31SStefan Hajnoczi         bdrv_refresh_limits(bs->backing_hd, &local_err);
21361007b31SStefan Hajnoczi         if (local_err) {
21461007b31SStefan Hajnoczi             error_propagate(errp, local_err);
21561007b31SStefan Hajnoczi             return;
21661007b31SStefan Hajnoczi         }
21761007b31SStefan Hajnoczi         bs->bl.opt_transfer_length =
21861007b31SStefan Hajnoczi             MAX(bs->bl.opt_transfer_length,
21961007b31SStefan Hajnoczi                 bs->backing_hd->bl.opt_transfer_length);
22061007b31SStefan Hajnoczi         bs->bl.max_transfer_length =
22161007b31SStefan Hajnoczi             MIN_NON_ZERO(bs->bl.max_transfer_length,
22261007b31SStefan Hajnoczi                          bs->backing_hd->bl.max_transfer_length);
22361007b31SStefan Hajnoczi         bs->bl.opt_mem_alignment =
22461007b31SStefan Hajnoczi             MAX(bs->bl.opt_mem_alignment,
22561007b31SStefan Hajnoczi                 bs->backing_hd->bl.opt_mem_alignment);
2264196d2f0SDenis V. Lunev         bs->bl.min_mem_alignment =
2274196d2f0SDenis V. Lunev             MAX(bs->bl.min_mem_alignment,
2284196d2f0SDenis V. Lunev                 bs->backing_hd->bl.min_mem_alignment);
22961007b31SStefan Hajnoczi     }
23061007b31SStefan Hajnoczi 
23161007b31SStefan Hajnoczi     /* Then let the driver override it */
23261007b31SStefan Hajnoczi     if (drv->bdrv_refresh_limits) {
23361007b31SStefan Hajnoczi         drv->bdrv_refresh_limits(bs, errp);
23461007b31SStefan Hajnoczi     }
23561007b31SStefan Hajnoczi }
23661007b31SStefan Hajnoczi 
23761007b31SStefan Hajnoczi /**
23861007b31SStefan Hajnoczi  * The copy-on-read flag is actually a reference count so multiple users may
23961007b31SStefan Hajnoczi  * use the feature without worrying about clobbering its previous state.
24061007b31SStefan Hajnoczi  * Copy-on-read stays enabled until all users have called to disable it.
24161007b31SStefan Hajnoczi  */
24261007b31SStefan Hajnoczi void bdrv_enable_copy_on_read(BlockDriverState *bs)
24361007b31SStefan Hajnoczi {
24461007b31SStefan Hajnoczi     bs->copy_on_read++;
24561007b31SStefan Hajnoczi }
24661007b31SStefan Hajnoczi 
24761007b31SStefan Hajnoczi void bdrv_disable_copy_on_read(BlockDriverState *bs)
24861007b31SStefan Hajnoczi {
24961007b31SStefan Hajnoczi     assert(bs->copy_on_read > 0);
25061007b31SStefan Hajnoczi     bs->copy_on_read--;
25161007b31SStefan Hajnoczi }
25261007b31SStefan Hajnoczi 
25361007b31SStefan Hajnoczi /* Check if any requests are in-flight (including throttled requests) */
25461007b31SStefan Hajnoczi static bool bdrv_requests_pending(BlockDriverState *bs)
25561007b31SStefan Hajnoczi {
25661007b31SStefan Hajnoczi     if (!QLIST_EMPTY(&bs->tracked_requests)) {
25761007b31SStefan Hajnoczi         return true;
25861007b31SStefan Hajnoczi     }
25961007b31SStefan Hajnoczi     if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
26061007b31SStefan Hajnoczi         return true;
26161007b31SStefan Hajnoczi     }
26261007b31SStefan Hajnoczi     if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
26361007b31SStefan Hajnoczi         return true;
26461007b31SStefan Hajnoczi     }
26561007b31SStefan Hajnoczi     if (bs->file && bdrv_requests_pending(bs->file)) {
26661007b31SStefan Hajnoczi         return true;
26761007b31SStefan Hajnoczi     }
26861007b31SStefan Hajnoczi     if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
26961007b31SStefan Hajnoczi         return true;
27061007b31SStefan Hajnoczi     }
27161007b31SStefan Hajnoczi     return false;
27261007b31SStefan Hajnoczi }
27361007b31SStefan Hajnoczi 
27461007b31SStefan Hajnoczi static bool bdrv_drain_one(BlockDriverState *bs)
27561007b31SStefan Hajnoczi {
27661007b31SStefan Hajnoczi     bool bs_busy;
27761007b31SStefan Hajnoczi 
27861007b31SStefan Hajnoczi     bdrv_flush_io_queue(bs);
27961007b31SStefan Hajnoczi     bdrv_start_throttled_reqs(bs);
28061007b31SStefan Hajnoczi     bs_busy = bdrv_requests_pending(bs);
28161007b31SStefan Hajnoczi     bs_busy |= aio_poll(bdrv_get_aio_context(bs), bs_busy);
28261007b31SStefan Hajnoczi     return bs_busy;
28361007b31SStefan Hajnoczi }
28461007b31SStefan Hajnoczi 
28561007b31SStefan Hajnoczi /*
28661007b31SStefan Hajnoczi  * Wait for pending requests to complete on a single BlockDriverState subtree
28761007b31SStefan Hajnoczi  *
28861007b31SStefan Hajnoczi  * See the warning in bdrv_drain_all().  This function can only be called if
28961007b31SStefan Hajnoczi  * you are sure nothing can generate I/O because you have op blockers
29061007b31SStefan Hajnoczi  * installed.
29161007b31SStefan Hajnoczi  *
29261007b31SStefan Hajnoczi  * Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState
29361007b31SStefan Hajnoczi  * AioContext.
29461007b31SStefan Hajnoczi  */
29561007b31SStefan Hajnoczi void bdrv_drain(BlockDriverState *bs)
29661007b31SStefan Hajnoczi {
29761007b31SStefan Hajnoczi     while (bdrv_drain_one(bs)) {
29861007b31SStefan Hajnoczi         /* Keep iterating */
29961007b31SStefan Hajnoczi     }
30061007b31SStefan Hajnoczi }
30161007b31SStefan Hajnoczi 
30261007b31SStefan Hajnoczi /*
30361007b31SStefan Hajnoczi  * Wait for pending requests to complete across all BlockDriverStates
30461007b31SStefan Hajnoczi  *
30561007b31SStefan Hajnoczi  * This function does not flush data to disk, use bdrv_flush_all() for that
30661007b31SStefan Hajnoczi  * after calling this function.
30761007b31SStefan Hajnoczi  *
30861007b31SStefan Hajnoczi  * Note that completion of an asynchronous I/O operation can trigger any
30961007b31SStefan Hajnoczi  * number of other I/O operations on other devices---for example a coroutine
31061007b31SStefan Hajnoczi  * can be arbitrarily complex and a constant flow of I/O can come until the
31161007b31SStefan Hajnoczi  * coroutine is complete.  Because of this, it is not possible to have a
31261007b31SStefan Hajnoczi  * function to drain a single device's I/O queue.
31361007b31SStefan Hajnoczi  */
31461007b31SStefan Hajnoczi void bdrv_drain_all(void)
31561007b31SStefan Hajnoczi {
31661007b31SStefan Hajnoczi     /* Always run first iteration so any pending completion BHs run */
31761007b31SStefan Hajnoczi     bool busy = true;
31861007b31SStefan Hajnoczi     BlockDriverState *bs = NULL;
31961007b31SStefan Hajnoczi 
32061007b31SStefan Hajnoczi     while ((bs = bdrv_next(bs))) {
32161007b31SStefan Hajnoczi         AioContext *aio_context = bdrv_get_aio_context(bs);
32261007b31SStefan Hajnoczi 
32361007b31SStefan Hajnoczi         aio_context_acquire(aio_context);
32461007b31SStefan Hajnoczi         if (bs->job) {
32561007b31SStefan Hajnoczi             block_job_pause(bs->job);
32661007b31SStefan Hajnoczi         }
32761007b31SStefan Hajnoczi         aio_context_release(aio_context);
32861007b31SStefan Hajnoczi     }
32961007b31SStefan Hajnoczi 
33061007b31SStefan Hajnoczi     while (busy) {
33161007b31SStefan Hajnoczi         busy = false;
33261007b31SStefan Hajnoczi         bs = NULL;
33361007b31SStefan Hajnoczi 
33461007b31SStefan Hajnoczi         while ((bs = bdrv_next(bs))) {
33561007b31SStefan Hajnoczi             AioContext *aio_context = bdrv_get_aio_context(bs);
33661007b31SStefan Hajnoczi 
33761007b31SStefan Hajnoczi             aio_context_acquire(aio_context);
33861007b31SStefan Hajnoczi             busy |= bdrv_drain_one(bs);
33961007b31SStefan Hajnoczi             aio_context_release(aio_context);
34061007b31SStefan Hajnoczi         }
34161007b31SStefan Hajnoczi     }
34261007b31SStefan Hajnoczi 
34361007b31SStefan Hajnoczi     bs = NULL;
34461007b31SStefan Hajnoczi     while ((bs = bdrv_next(bs))) {
34561007b31SStefan Hajnoczi         AioContext *aio_context = bdrv_get_aio_context(bs);
34661007b31SStefan Hajnoczi 
34761007b31SStefan Hajnoczi         aio_context_acquire(aio_context);
34861007b31SStefan Hajnoczi         if (bs->job) {
34961007b31SStefan Hajnoczi             block_job_resume(bs->job);
35061007b31SStefan Hajnoczi         }
35161007b31SStefan Hajnoczi         aio_context_release(aio_context);
35261007b31SStefan Hajnoczi     }
35361007b31SStefan Hajnoczi }
35461007b31SStefan Hajnoczi 
35561007b31SStefan Hajnoczi /**
35661007b31SStefan Hajnoczi  * Remove an active request from the tracked requests list
35761007b31SStefan Hajnoczi  *
35861007b31SStefan Hajnoczi  * This function should be called when a tracked request is completing.
35961007b31SStefan Hajnoczi  */
36061007b31SStefan Hajnoczi static void tracked_request_end(BdrvTrackedRequest *req)
36161007b31SStefan Hajnoczi {
36261007b31SStefan Hajnoczi     if (req->serialising) {
36361007b31SStefan Hajnoczi         req->bs->serialising_in_flight--;
36461007b31SStefan Hajnoczi     }
36561007b31SStefan Hajnoczi 
36661007b31SStefan Hajnoczi     QLIST_REMOVE(req, list);
36761007b31SStefan Hajnoczi     qemu_co_queue_restart_all(&req->wait_queue);
36861007b31SStefan Hajnoczi }
36961007b31SStefan Hajnoczi 
37061007b31SStefan Hajnoczi /**
37161007b31SStefan Hajnoczi  * Add an active request to the tracked requests list
37261007b31SStefan Hajnoczi  */
37361007b31SStefan Hajnoczi static void tracked_request_begin(BdrvTrackedRequest *req,
37461007b31SStefan Hajnoczi                                   BlockDriverState *bs,
37561007b31SStefan Hajnoczi                                   int64_t offset,
37661007b31SStefan Hajnoczi                                   unsigned int bytes, bool is_write)
37761007b31SStefan Hajnoczi {
37861007b31SStefan Hajnoczi     *req = (BdrvTrackedRequest){
37961007b31SStefan Hajnoczi         .bs = bs,
38061007b31SStefan Hajnoczi         .offset         = offset,
38161007b31SStefan Hajnoczi         .bytes          = bytes,
38261007b31SStefan Hajnoczi         .is_write       = is_write,
38361007b31SStefan Hajnoczi         .co             = qemu_coroutine_self(),
38461007b31SStefan Hajnoczi         .serialising    = false,
38561007b31SStefan Hajnoczi         .overlap_offset = offset,
38661007b31SStefan Hajnoczi         .overlap_bytes  = bytes,
38761007b31SStefan Hajnoczi     };
38861007b31SStefan Hajnoczi 
38961007b31SStefan Hajnoczi     qemu_co_queue_init(&req->wait_queue);
39061007b31SStefan Hajnoczi 
39161007b31SStefan Hajnoczi     QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
39261007b31SStefan Hajnoczi }
39361007b31SStefan Hajnoczi 
39461007b31SStefan Hajnoczi static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
39561007b31SStefan Hajnoczi {
39661007b31SStefan Hajnoczi     int64_t overlap_offset = req->offset & ~(align - 1);
39761007b31SStefan Hajnoczi     unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
39861007b31SStefan Hajnoczi                                - overlap_offset;
39961007b31SStefan Hajnoczi 
40061007b31SStefan Hajnoczi     if (!req->serialising) {
40161007b31SStefan Hajnoczi         req->bs->serialising_in_flight++;
40261007b31SStefan Hajnoczi         req->serialising = true;
40361007b31SStefan Hajnoczi     }
40461007b31SStefan Hajnoczi 
40561007b31SStefan Hajnoczi     req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
40661007b31SStefan Hajnoczi     req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
40761007b31SStefan Hajnoczi }
40861007b31SStefan Hajnoczi 
40961007b31SStefan Hajnoczi /**
41061007b31SStefan Hajnoczi  * Round a region to cluster boundaries
41161007b31SStefan Hajnoczi  */
41261007b31SStefan Hajnoczi void bdrv_round_to_clusters(BlockDriverState *bs,
41361007b31SStefan Hajnoczi                             int64_t sector_num, int nb_sectors,
41461007b31SStefan Hajnoczi                             int64_t *cluster_sector_num,
41561007b31SStefan Hajnoczi                             int *cluster_nb_sectors)
41661007b31SStefan Hajnoczi {
41761007b31SStefan Hajnoczi     BlockDriverInfo bdi;
41861007b31SStefan Hajnoczi 
41961007b31SStefan Hajnoczi     if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
42061007b31SStefan Hajnoczi         *cluster_sector_num = sector_num;
42161007b31SStefan Hajnoczi         *cluster_nb_sectors = nb_sectors;
42261007b31SStefan Hajnoczi     } else {
42361007b31SStefan Hajnoczi         int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
42461007b31SStefan Hajnoczi         *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
42561007b31SStefan Hajnoczi         *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
42661007b31SStefan Hajnoczi                                             nb_sectors, c);
42761007b31SStefan Hajnoczi     }
42861007b31SStefan Hajnoczi }
42961007b31SStefan Hajnoczi 
43061007b31SStefan Hajnoczi static int bdrv_get_cluster_size(BlockDriverState *bs)
43161007b31SStefan Hajnoczi {
43261007b31SStefan Hajnoczi     BlockDriverInfo bdi;
43361007b31SStefan Hajnoczi     int ret;
43461007b31SStefan Hajnoczi 
43561007b31SStefan Hajnoczi     ret = bdrv_get_info(bs, &bdi);
43661007b31SStefan Hajnoczi     if (ret < 0 || bdi.cluster_size == 0) {
43761007b31SStefan Hajnoczi         return bs->request_alignment;
43861007b31SStefan Hajnoczi     } else {
43961007b31SStefan Hajnoczi         return bdi.cluster_size;
44061007b31SStefan Hajnoczi     }
44161007b31SStefan Hajnoczi }
44261007b31SStefan Hajnoczi 
44361007b31SStefan Hajnoczi static bool tracked_request_overlaps(BdrvTrackedRequest *req,
44461007b31SStefan Hajnoczi                                      int64_t offset, unsigned int bytes)
44561007b31SStefan Hajnoczi {
44661007b31SStefan Hajnoczi     /*        aaaa   bbbb */
44761007b31SStefan Hajnoczi     if (offset >= req->overlap_offset + req->overlap_bytes) {
44861007b31SStefan Hajnoczi         return false;
44961007b31SStefan Hajnoczi     }
45061007b31SStefan Hajnoczi     /* bbbb   aaaa        */
45161007b31SStefan Hajnoczi     if (req->overlap_offset >= offset + bytes) {
45261007b31SStefan Hajnoczi         return false;
45361007b31SStefan Hajnoczi     }
45461007b31SStefan Hajnoczi     return true;
45561007b31SStefan Hajnoczi }
45661007b31SStefan Hajnoczi 
45761007b31SStefan Hajnoczi static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
45861007b31SStefan Hajnoczi {
45961007b31SStefan Hajnoczi     BlockDriverState *bs = self->bs;
46061007b31SStefan Hajnoczi     BdrvTrackedRequest *req;
46161007b31SStefan Hajnoczi     bool retry;
46261007b31SStefan Hajnoczi     bool waited = false;
46361007b31SStefan Hajnoczi 
46461007b31SStefan Hajnoczi     if (!bs->serialising_in_flight) {
46561007b31SStefan Hajnoczi         return false;
46661007b31SStefan Hajnoczi     }
46761007b31SStefan Hajnoczi 
46861007b31SStefan Hajnoczi     do {
46961007b31SStefan Hajnoczi         retry = false;
47061007b31SStefan Hajnoczi         QLIST_FOREACH(req, &bs->tracked_requests, list) {
47161007b31SStefan Hajnoczi             if (req == self || (!req->serialising && !self->serialising)) {
47261007b31SStefan Hajnoczi                 continue;
47361007b31SStefan Hajnoczi             }
47461007b31SStefan Hajnoczi             if (tracked_request_overlaps(req, self->overlap_offset,
47561007b31SStefan Hajnoczi                                          self->overlap_bytes))
47661007b31SStefan Hajnoczi             {
47761007b31SStefan Hajnoczi                 /* Hitting this means there was a reentrant request, for
47861007b31SStefan Hajnoczi                  * example, a block driver issuing nested requests.  This must
47961007b31SStefan Hajnoczi                  * never happen since it means deadlock.
48061007b31SStefan Hajnoczi                  */
48161007b31SStefan Hajnoczi                 assert(qemu_coroutine_self() != req->co);
48261007b31SStefan Hajnoczi 
48361007b31SStefan Hajnoczi                 /* If the request is already (indirectly) waiting for us, or
48461007b31SStefan Hajnoczi                  * will wait for us as soon as it wakes up, then just go on
48561007b31SStefan Hajnoczi                  * (instead of producing a deadlock in the former case). */
48661007b31SStefan Hajnoczi                 if (!req->waiting_for) {
48761007b31SStefan Hajnoczi                     self->waiting_for = req;
48861007b31SStefan Hajnoczi                     qemu_co_queue_wait(&req->wait_queue);
48961007b31SStefan Hajnoczi                     self->waiting_for = NULL;
49061007b31SStefan Hajnoczi                     retry = true;
49161007b31SStefan Hajnoczi                     waited = true;
49261007b31SStefan Hajnoczi                     break;
49361007b31SStefan Hajnoczi                 }
49461007b31SStefan Hajnoczi             }
49561007b31SStefan Hajnoczi         }
49661007b31SStefan Hajnoczi     } while (retry);
49761007b31SStefan Hajnoczi 
49861007b31SStefan Hajnoczi     return waited;
49961007b31SStefan Hajnoczi }
50061007b31SStefan Hajnoczi 
50161007b31SStefan Hajnoczi static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
50261007b31SStefan Hajnoczi                                    size_t size)
50361007b31SStefan Hajnoczi {
50461007b31SStefan Hajnoczi     if (size > BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS) {
50561007b31SStefan Hajnoczi         return -EIO;
50661007b31SStefan Hajnoczi     }
50761007b31SStefan Hajnoczi 
50861007b31SStefan Hajnoczi     if (!bdrv_is_inserted(bs)) {
50961007b31SStefan Hajnoczi         return -ENOMEDIUM;
51061007b31SStefan Hajnoczi     }
51161007b31SStefan Hajnoczi 
51261007b31SStefan Hajnoczi     if (offset < 0) {
51361007b31SStefan Hajnoczi         return -EIO;
51461007b31SStefan Hajnoczi     }
51561007b31SStefan Hajnoczi 
51661007b31SStefan Hajnoczi     return 0;
51761007b31SStefan Hajnoczi }
51861007b31SStefan Hajnoczi 
51961007b31SStefan Hajnoczi static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
52061007b31SStefan Hajnoczi                               int nb_sectors)
52161007b31SStefan Hajnoczi {
52261007b31SStefan Hajnoczi     if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
52361007b31SStefan Hajnoczi         return -EIO;
52461007b31SStefan Hajnoczi     }
52561007b31SStefan Hajnoczi 
52661007b31SStefan Hajnoczi     return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
52761007b31SStefan Hajnoczi                                    nb_sectors * BDRV_SECTOR_SIZE);
52861007b31SStefan Hajnoczi }
52961007b31SStefan Hajnoczi 
53061007b31SStefan Hajnoczi typedef struct RwCo {
53161007b31SStefan Hajnoczi     BlockDriverState *bs;
53261007b31SStefan Hajnoczi     int64_t offset;
53361007b31SStefan Hajnoczi     QEMUIOVector *qiov;
53461007b31SStefan Hajnoczi     bool is_write;
53561007b31SStefan Hajnoczi     int ret;
53661007b31SStefan Hajnoczi     BdrvRequestFlags flags;
53761007b31SStefan Hajnoczi } RwCo;
53861007b31SStefan Hajnoczi 
53961007b31SStefan Hajnoczi static void coroutine_fn bdrv_rw_co_entry(void *opaque)
54061007b31SStefan Hajnoczi {
54161007b31SStefan Hajnoczi     RwCo *rwco = opaque;
54261007b31SStefan Hajnoczi 
54361007b31SStefan Hajnoczi     if (!rwco->is_write) {
54461007b31SStefan Hajnoczi         rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
54561007b31SStefan Hajnoczi                                       rwco->qiov->size, rwco->qiov,
54661007b31SStefan Hajnoczi                                       rwco->flags);
54761007b31SStefan Hajnoczi     } else {
54861007b31SStefan Hajnoczi         rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
54961007b31SStefan Hajnoczi                                        rwco->qiov->size, rwco->qiov,
55061007b31SStefan Hajnoczi                                        rwco->flags);
55161007b31SStefan Hajnoczi     }
55261007b31SStefan Hajnoczi }
55361007b31SStefan Hajnoczi 
55461007b31SStefan Hajnoczi /*
55561007b31SStefan Hajnoczi  * Process a vectored synchronous request using coroutines
55661007b31SStefan Hajnoczi  */
55761007b31SStefan Hajnoczi static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
55861007b31SStefan Hajnoczi                         QEMUIOVector *qiov, bool is_write,
55961007b31SStefan Hajnoczi                         BdrvRequestFlags flags)
56061007b31SStefan Hajnoczi {
56161007b31SStefan Hajnoczi     Coroutine *co;
56261007b31SStefan Hajnoczi     RwCo rwco = {
56361007b31SStefan Hajnoczi         .bs = bs,
56461007b31SStefan Hajnoczi         .offset = offset,
56561007b31SStefan Hajnoczi         .qiov = qiov,
56661007b31SStefan Hajnoczi         .is_write = is_write,
56761007b31SStefan Hajnoczi         .ret = NOT_DONE,
56861007b31SStefan Hajnoczi         .flags = flags,
56961007b31SStefan Hajnoczi     };
57061007b31SStefan Hajnoczi 
57161007b31SStefan Hajnoczi     /**
57261007b31SStefan Hajnoczi      * In sync call context, when the vcpu is blocked, this throttling timer
57361007b31SStefan Hajnoczi      * will not fire; so the I/O throttling function has to be disabled here
57461007b31SStefan Hajnoczi      * if it has been enabled.
57561007b31SStefan Hajnoczi      */
57661007b31SStefan Hajnoczi     if (bs->io_limits_enabled) {
57761007b31SStefan Hajnoczi         fprintf(stderr, "Disabling I/O throttling on '%s' due "
57861007b31SStefan Hajnoczi                         "to synchronous I/O.\n", bdrv_get_device_name(bs));
57961007b31SStefan Hajnoczi         bdrv_io_limits_disable(bs);
58061007b31SStefan Hajnoczi     }
58161007b31SStefan Hajnoczi 
58261007b31SStefan Hajnoczi     if (qemu_in_coroutine()) {
58361007b31SStefan Hajnoczi         /* Fast-path if already in coroutine context */
58461007b31SStefan Hajnoczi         bdrv_rw_co_entry(&rwco);
58561007b31SStefan Hajnoczi     } else {
58661007b31SStefan Hajnoczi         AioContext *aio_context = bdrv_get_aio_context(bs);
58761007b31SStefan Hajnoczi 
58861007b31SStefan Hajnoczi         co = qemu_coroutine_create(bdrv_rw_co_entry);
58961007b31SStefan Hajnoczi         qemu_coroutine_enter(co, &rwco);
59061007b31SStefan Hajnoczi         while (rwco.ret == NOT_DONE) {
59161007b31SStefan Hajnoczi             aio_poll(aio_context, true);
59261007b31SStefan Hajnoczi         }
59361007b31SStefan Hajnoczi     }
59461007b31SStefan Hajnoczi     return rwco.ret;
59561007b31SStefan Hajnoczi }
59661007b31SStefan Hajnoczi 
59761007b31SStefan Hajnoczi /*
59861007b31SStefan Hajnoczi  * Process a synchronous request using coroutines
59961007b31SStefan Hajnoczi  */
60061007b31SStefan Hajnoczi static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
60161007b31SStefan Hajnoczi                       int nb_sectors, bool is_write, BdrvRequestFlags flags)
60261007b31SStefan Hajnoczi {
60361007b31SStefan Hajnoczi     QEMUIOVector qiov;
60461007b31SStefan Hajnoczi     struct iovec iov = {
60561007b31SStefan Hajnoczi         .iov_base = (void *)buf,
60661007b31SStefan Hajnoczi         .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
60761007b31SStefan Hajnoczi     };
60861007b31SStefan Hajnoczi 
60961007b31SStefan Hajnoczi     if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
61061007b31SStefan Hajnoczi         return -EINVAL;
61161007b31SStefan Hajnoczi     }
61261007b31SStefan Hajnoczi 
61361007b31SStefan Hajnoczi     qemu_iovec_init_external(&qiov, &iov, 1);
61461007b31SStefan Hajnoczi     return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
61561007b31SStefan Hajnoczi                         &qiov, is_write, flags);
61661007b31SStefan Hajnoczi }
61761007b31SStefan Hajnoczi 
61861007b31SStefan Hajnoczi /* return < 0 if error. See bdrv_write() for the return codes */
61961007b31SStefan Hajnoczi int bdrv_read(BlockDriverState *bs, int64_t sector_num,
62061007b31SStefan Hajnoczi               uint8_t *buf, int nb_sectors)
62161007b31SStefan Hajnoczi {
62261007b31SStefan Hajnoczi     return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
62361007b31SStefan Hajnoczi }
62461007b31SStefan Hajnoczi 
62561007b31SStefan Hajnoczi /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
62661007b31SStefan Hajnoczi int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
62761007b31SStefan Hajnoczi                           uint8_t *buf, int nb_sectors)
62861007b31SStefan Hajnoczi {
62961007b31SStefan Hajnoczi     bool enabled;
63061007b31SStefan Hajnoczi     int ret;
63161007b31SStefan Hajnoczi 
63261007b31SStefan Hajnoczi     enabled = bs->io_limits_enabled;
63361007b31SStefan Hajnoczi     bs->io_limits_enabled = false;
63461007b31SStefan Hajnoczi     ret = bdrv_read(bs, sector_num, buf, nb_sectors);
63561007b31SStefan Hajnoczi     bs->io_limits_enabled = enabled;
63661007b31SStefan Hajnoczi     return ret;
63761007b31SStefan Hajnoczi }
63861007b31SStefan Hajnoczi 
63961007b31SStefan Hajnoczi /* Return < 0 if error. Important errors are:
64061007b31SStefan Hajnoczi   -EIO         generic I/O error (may happen for all errors)
64161007b31SStefan Hajnoczi   -ENOMEDIUM   No media inserted.
64261007b31SStefan Hajnoczi   -EINVAL      Invalid sector number or nb_sectors
64361007b31SStefan Hajnoczi   -EACCES      Trying to write a read-only device
64461007b31SStefan Hajnoczi */
64561007b31SStefan Hajnoczi int bdrv_write(BlockDriverState *bs, int64_t sector_num,
64661007b31SStefan Hajnoczi                const uint8_t *buf, int nb_sectors)
64761007b31SStefan Hajnoczi {
64861007b31SStefan Hajnoczi     return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
64961007b31SStefan Hajnoczi }
65061007b31SStefan Hajnoczi 
65161007b31SStefan Hajnoczi int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
65261007b31SStefan Hajnoczi                       int nb_sectors, BdrvRequestFlags flags)
65361007b31SStefan Hajnoczi {
65461007b31SStefan Hajnoczi     return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
65561007b31SStefan Hajnoczi                       BDRV_REQ_ZERO_WRITE | flags);
65661007b31SStefan Hajnoczi }
65761007b31SStefan Hajnoczi 
65861007b31SStefan Hajnoczi /*
65961007b31SStefan Hajnoczi  * Completely zero out a block device with the help of bdrv_write_zeroes.
66061007b31SStefan Hajnoczi  * The operation is sped up by checking the block status and only writing
66161007b31SStefan Hajnoczi  * zeroes to the device if they currently do not return zeroes. Optional
66261007b31SStefan Hajnoczi  * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
66361007b31SStefan Hajnoczi  *
66461007b31SStefan Hajnoczi  * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
66561007b31SStefan Hajnoczi  */
66661007b31SStefan Hajnoczi int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
66761007b31SStefan Hajnoczi {
66861007b31SStefan Hajnoczi     int64_t target_sectors, ret, nb_sectors, sector_num = 0;
66961007b31SStefan Hajnoczi     int n;
67061007b31SStefan Hajnoczi 
67161007b31SStefan Hajnoczi     target_sectors = bdrv_nb_sectors(bs);
67261007b31SStefan Hajnoczi     if (target_sectors < 0) {
67361007b31SStefan Hajnoczi         return target_sectors;
67461007b31SStefan Hajnoczi     }
67561007b31SStefan Hajnoczi 
67661007b31SStefan Hajnoczi     for (;;) {
67761007b31SStefan Hajnoczi         nb_sectors = MIN(target_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
67861007b31SStefan Hajnoczi         if (nb_sectors <= 0) {
67961007b31SStefan Hajnoczi             return 0;
68061007b31SStefan Hajnoczi         }
68161007b31SStefan Hajnoczi         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
68261007b31SStefan Hajnoczi         if (ret < 0) {
68361007b31SStefan Hajnoczi             error_report("error getting block status at sector %" PRId64 ": %s",
68461007b31SStefan Hajnoczi                          sector_num, strerror(-ret));
68561007b31SStefan Hajnoczi             return ret;
68661007b31SStefan Hajnoczi         }
68761007b31SStefan Hajnoczi         if (ret & BDRV_BLOCK_ZERO) {
68861007b31SStefan Hajnoczi             sector_num += n;
68961007b31SStefan Hajnoczi             continue;
69061007b31SStefan Hajnoczi         }
69161007b31SStefan Hajnoczi         ret = bdrv_write_zeroes(bs, sector_num, n, flags);
69261007b31SStefan Hajnoczi         if (ret < 0) {
69361007b31SStefan Hajnoczi             error_report("error writing zeroes at sector %" PRId64 ": %s",
69461007b31SStefan Hajnoczi                          sector_num, strerror(-ret));
69561007b31SStefan Hajnoczi             return ret;
69661007b31SStefan Hajnoczi         }
69761007b31SStefan Hajnoczi         sector_num += n;
69861007b31SStefan Hajnoczi     }
69961007b31SStefan Hajnoczi }
70061007b31SStefan Hajnoczi 
70161007b31SStefan Hajnoczi int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
70261007b31SStefan Hajnoczi {
70361007b31SStefan Hajnoczi     QEMUIOVector qiov;
70461007b31SStefan Hajnoczi     struct iovec iov = {
70561007b31SStefan Hajnoczi         .iov_base = (void *)buf,
70661007b31SStefan Hajnoczi         .iov_len = bytes,
70761007b31SStefan Hajnoczi     };
70861007b31SStefan Hajnoczi     int ret;
70961007b31SStefan Hajnoczi 
71061007b31SStefan Hajnoczi     if (bytes < 0) {
71161007b31SStefan Hajnoczi         return -EINVAL;
71261007b31SStefan Hajnoczi     }
71361007b31SStefan Hajnoczi 
71461007b31SStefan Hajnoczi     qemu_iovec_init_external(&qiov, &iov, 1);
71561007b31SStefan Hajnoczi     ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
71661007b31SStefan Hajnoczi     if (ret < 0) {
71761007b31SStefan Hajnoczi         return ret;
71861007b31SStefan Hajnoczi     }
71961007b31SStefan Hajnoczi 
72061007b31SStefan Hajnoczi     return bytes;
72161007b31SStefan Hajnoczi }
72261007b31SStefan Hajnoczi 
72361007b31SStefan Hajnoczi int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
72461007b31SStefan Hajnoczi {
72561007b31SStefan Hajnoczi     int ret;
72661007b31SStefan Hajnoczi 
72761007b31SStefan Hajnoczi     ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
72861007b31SStefan Hajnoczi     if (ret < 0) {
72961007b31SStefan Hajnoczi         return ret;
73061007b31SStefan Hajnoczi     }
73161007b31SStefan Hajnoczi 
73261007b31SStefan Hajnoczi     return qiov->size;
73361007b31SStefan Hajnoczi }
73461007b31SStefan Hajnoczi 
73561007b31SStefan Hajnoczi int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
73661007b31SStefan Hajnoczi                 const void *buf, int bytes)
73761007b31SStefan Hajnoczi {
73861007b31SStefan Hajnoczi     QEMUIOVector qiov;
73961007b31SStefan Hajnoczi     struct iovec iov = {
74061007b31SStefan Hajnoczi         .iov_base   = (void *) buf,
74161007b31SStefan Hajnoczi         .iov_len    = bytes,
74261007b31SStefan Hajnoczi     };
74361007b31SStefan Hajnoczi 
74461007b31SStefan Hajnoczi     if (bytes < 0) {
74561007b31SStefan Hajnoczi         return -EINVAL;
74661007b31SStefan Hajnoczi     }
74761007b31SStefan Hajnoczi 
74861007b31SStefan Hajnoczi     qemu_iovec_init_external(&qiov, &iov, 1);
74961007b31SStefan Hajnoczi     return bdrv_pwritev(bs, offset, &qiov);
75061007b31SStefan Hajnoczi }
75161007b31SStefan Hajnoczi 
75261007b31SStefan Hajnoczi /*
75361007b31SStefan Hajnoczi  * Writes to the file and ensures that no writes are reordered across this
75461007b31SStefan Hajnoczi  * request (acts as a barrier)
75561007b31SStefan Hajnoczi  *
75661007b31SStefan Hajnoczi  * Returns 0 on success, -errno in error cases.
75761007b31SStefan Hajnoczi  */
75861007b31SStefan Hajnoczi int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
75961007b31SStefan Hajnoczi     const void *buf, int count)
76061007b31SStefan Hajnoczi {
76161007b31SStefan Hajnoczi     int ret;
76261007b31SStefan Hajnoczi 
76361007b31SStefan Hajnoczi     ret = bdrv_pwrite(bs, offset, buf, count);
76461007b31SStefan Hajnoczi     if (ret < 0) {
76561007b31SStefan Hajnoczi         return ret;
76661007b31SStefan Hajnoczi     }
76761007b31SStefan Hajnoczi 
76861007b31SStefan Hajnoczi     /* No flush needed for cache modes that already do it */
76961007b31SStefan Hajnoczi     if (bs->enable_write_cache) {
77061007b31SStefan Hajnoczi         bdrv_flush(bs);
77161007b31SStefan Hajnoczi     }
77261007b31SStefan Hajnoczi 
77361007b31SStefan Hajnoczi     return 0;
77461007b31SStefan Hajnoczi }
77561007b31SStefan Hajnoczi 
77661007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
77761007b31SStefan Hajnoczi         int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
77861007b31SStefan Hajnoczi {
77961007b31SStefan Hajnoczi     /* Perform I/O through a temporary buffer so that users who scribble over
78061007b31SStefan Hajnoczi      * their read buffer while the operation is in progress do not end up
78161007b31SStefan Hajnoczi      * modifying the image file.  This is critical for zero-copy guest I/O
78261007b31SStefan Hajnoczi      * where anything might happen inside guest memory.
78361007b31SStefan Hajnoczi      */
78461007b31SStefan Hajnoczi     void *bounce_buffer;
78561007b31SStefan Hajnoczi 
78661007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
78761007b31SStefan Hajnoczi     struct iovec iov;
78861007b31SStefan Hajnoczi     QEMUIOVector bounce_qiov;
78961007b31SStefan Hajnoczi     int64_t cluster_sector_num;
79061007b31SStefan Hajnoczi     int cluster_nb_sectors;
79161007b31SStefan Hajnoczi     size_t skip_bytes;
79261007b31SStefan Hajnoczi     int ret;
79361007b31SStefan Hajnoczi 
79461007b31SStefan Hajnoczi     /* Cover entire cluster so no additional backing file I/O is required when
79561007b31SStefan Hajnoczi      * allocating cluster in the image file.
79661007b31SStefan Hajnoczi      */
79761007b31SStefan Hajnoczi     bdrv_round_to_clusters(bs, sector_num, nb_sectors,
79861007b31SStefan Hajnoczi                            &cluster_sector_num, &cluster_nb_sectors);
79961007b31SStefan Hajnoczi 
80061007b31SStefan Hajnoczi     trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
80161007b31SStefan Hajnoczi                                    cluster_sector_num, cluster_nb_sectors);
80261007b31SStefan Hajnoczi 
80361007b31SStefan Hajnoczi     iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
80461007b31SStefan Hajnoczi     iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);
80561007b31SStefan Hajnoczi     if (bounce_buffer == NULL) {
80661007b31SStefan Hajnoczi         ret = -ENOMEM;
80761007b31SStefan Hajnoczi         goto err;
80861007b31SStefan Hajnoczi     }
80961007b31SStefan Hajnoczi 
81061007b31SStefan Hajnoczi     qemu_iovec_init_external(&bounce_qiov, &iov, 1);
81161007b31SStefan Hajnoczi 
81261007b31SStefan Hajnoczi     ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
81361007b31SStefan Hajnoczi                              &bounce_qiov);
81461007b31SStefan Hajnoczi     if (ret < 0) {
81561007b31SStefan Hajnoczi         goto err;
81661007b31SStefan Hajnoczi     }
81761007b31SStefan Hajnoczi 
81861007b31SStefan Hajnoczi     if (drv->bdrv_co_write_zeroes &&
81961007b31SStefan Hajnoczi         buffer_is_zero(bounce_buffer, iov.iov_len)) {
82061007b31SStefan Hajnoczi         ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
82161007b31SStefan Hajnoczi                                       cluster_nb_sectors, 0);
82261007b31SStefan Hajnoczi     } else {
82361007b31SStefan Hajnoczi         /* This does not change the data on the disk, it is not necessary
82461007b31SStefan Hajnoczi          * to flush even in cache=writethrough mode.
82561007b31SStefan Hajnoczi          */
82661007b31SStefan Hajnoczi         ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
82761007b31SStefan Hajnoczi                                   &bounce_qiov);
82861007b31SStefan Hajnoczi     }
82961007b31SStefan Hajnoczi 
83061007b31SStefan Hajnoczi     if (ret < 0) {
83161007b31SStefan Hajnoczi         /* It might be okay to ignore write errors for guest requests.  If this
83261007b31SStefan Hajnoczi          * is a deliberate copy-on-read then we don't want to ignore the error.
83361007b31SStefan Hajnoczi          * Simply report it in all cases.
83461007b31SStefan Hajnoczi          */
83561007b31SStefan Hajnoczi         goto err;
83661007b31SStefan Hajnoczi     }
83761007b31SStefan Hajnoczi 
83861007b31SStefan Hajnoczi     skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
83961007b31SStefan Hajnoczi     qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
84061007b31SStefan Hajnoczi                         nb_sectors * BDRV_SECTOR_SIZE);
84161007b31SStefan Hajnoczi 
84261007b31SStefan Hajnoczi err:
84361007b31SStefan Hajnoczi     qemu_vfree(bounce_buffer);
84461007b31SStefan Hajnoczi     return ret;
84561007b31SStefan Hajnoczi }
84661007b31SStefan Hajnoczi 
84761007b31SStefan Hajnoczi /*
84861007b31SStefan Hajnoczi  * Forwards an already correctly aligned request to the BlockDriver. This
84961007b31SStefan Hajnoczi  * handles copy on read and zeroing after EOF; any other features must be
85061007b31SStefan Hajnoczi  * implemented by the caller.
85161007b31SStefan Hajnoczi  */
85261007b31SStefan Hajnoczi static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
85361007b31SStefan Hajnoczi     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
85461007b31SStefan Hajnoczi     int64_t align, QEMUIOVector *qiov, int flags)
85561007b31SStefan Hajnoczi {
85661007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
85761007b31SStefan Hajnoczi     int ret;
85861007b31SStefan Hajnoczi 
85961007b31SStefan Hajnoczi     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
86061007b31SStefan Hajnoczi     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
86161007b31SStefan Hajnoczi 
86261007b31SStefan Hajnoczi     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
86361007b31SStefan Hajnoczi     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
86461007b31SStefan Hajnoczi     assert(!qiov || bytes == qiov->size);
86561007b31SStefan Hajnoczi 
86661007b31SStefan Hajnoczi     /* Handle Copy on Read and associated serialisation */
86761007b31SStefan Hajnoczi     if (flags & BDRV_REQ_COPY_ON_READ) {
86861007b31SStefan Hajnoczi         /* If we touch the same cluster it counts as an overlap.  This
86961007b31SStefan Hajnoczi          * guarantees that allocating writes will be serialized and not race
87061007b31SStefan Hajnoczi          * with each other for the same cluster.  For example, in copy-on-read
87161007b31SStefan Hajnoczi          * it ensures that the CoR read and write operations are atomic and
87261007b31SStefan Hajnoczi          * guest writes cannot interleave between them. */
87361007b31SStefan Hajnoczi         mark_request_serialising(req, bdrv_get_cluster_size(bs));
87461007b31SStefan Hajnoczi     }
87561007b31SStefan Hajnoczi 
87661007b31SStefan Hajnoczi     wait_serialising_requests(req);
87761007b31SStefan Hajnoczi 
87861007b31SStefan Hajnoczi     if (flags & BDRV_REQ_COPY_ON_READ) {
87961007b31SStefan Hajnoczi         int pnum;
88061007b31SStefan Hajnoczi 
88161007b31SStefan Hajnoczi         ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
88261007b31SStefan Hajnoczi         if (ret < 0) {
88361007b31SStefan Hajnoczi             goto out;
88461007b31SStefan Hajnoczi         }
88561007b31SStefan Hajnoczi 
88661007b31SStefan Hajnoczi         if (!ret || pnum != nb_sectors) {
88761007b31SStefan Hajnoczi             ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
88861007b31SStefan Hajnoczi             goto out;
88961007b31SStefan Hajnoczi         }
89061007b31SStefan Hajnoczi     }
89161007b31SStefan Hajnoczi 
89261007b31SStefan Hajnoczi     /* Forward the request to the BlockDriver */
89361007b31SStefan Hajnoczi     if (!bs->zero_beyond_eof) {
89461007b31SStefan Hajnoczi         ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
89561007b31SStefan Hajnoczi     } else {
89661007b31SStefan Hajnoczi         /* Read zeros after EOF */
89761007b31SStefan Hajnoczi         int64_t total_sectors, max_nb_sectors;
89861007b31SStefan Hajnoczi 
89961007b31SStefan Hajnoczi         total_sectors = bdrv_nb_sectors(bs);
90061007b31SStefan Hajnoczi         if (total_sectors < 0) {
90161007b31SStefan Hajnoczi             ret = total_sectors;
90261007b31SStefan Hajnoczi             goto out;
90361007b31SStefan Hajnoczi         }
90461007b31SStefan Hajnoczi 
90561007b31SStefan Hajnoczi         max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
90661007b31SStefan Hajnoczi                                   align >> BDRV_SECTOR_BITS);
90761007b31SStefan Hajnoczi         if (nb_sectors < max_nb_sectors) {
90861007b31SStefan Hajnoczi             ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
90961007b31SStefan Hajnoczi         } else if (max_nb_sectors > 0) {
91061007b31SStefan Hajnoczi             QEMUIOVector local_qiov;
91161007b31SStefan Hajnoczi 
91261007b31SStefan Hajnoczi             qemu_iovec_init(&local_qiov, qiov->niov);
91361007b31SStefan Hajnoczi             qemu_iovec_concat(&local_qiov, qiov, 0,
91461007b31SStefan Hajnoczi                               max_nb_sectors * BDRV_SECTOR_SIZE);
91561007b31SStefan Hajnoczi 
91661007b31SStefan Hajnoczi             ret = drv->bdrv_co_readv(bs, sector_num, max_nb_sectors,
91761007b31SStefan Hajnoczi                                      &local_qiov);
91861007b31SStefan Hajnoczi 
91961007b31SStefan Hajnoczi             qemu_iovec_destroy(&local_qiov);
92061007b31SStefan Hajnoczi         } else {
92161007b31SStefan Hajnoczi             ret = 0;
92261007b31SStefan Hajnoczi         }
92361007b31SStefan Hajnoczi 
92461007b31SStefan Hajnoczi         /* Reading beyond end of file is supposed to produce zeroes */
92561007b31SStefan Hajnoczi         if (ret == 0 && total_sectors < sector_num + nb_sectors) {
92661007b31SStefan Hajnoczi             uint64_t offset = MAX(0, total_sectors - sector_num);
92761007b31SStefan Hajnoczi             uint64_t bytes = (sector_num + nb_sectors - offset) *
92861007b31SStefan Hajnoczi                               BDRV_SECTOR_SIZE;
92961007b31SStefan Hajnoczi             qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
93061007b31SStefan Hajnoczi         }
93161007b31SStefan Hajnoczi     }
93261007b31SStefan Hajnoczi 
93361007b31SStefan Hajnoczi out:
93461007b31SStefan Hajnoczi     return ret;
93561007b31SStefan Hajnoczi }
93661007b31SStefan Hajnoczi 
93761007b31SStefan Hajnoczi /*
93861007b31SStefan Hajnoczi  * Handle a read request in coroutine context
93961007b31SStefan Hajnoczi  */
94061007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
94161007b31SStefan Hajnoczi     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
94261007b31SStefan Hajnoczi     BdrvRequestFlags flags)
94361007b31SStefan Hajnoczi {
94461007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
94561007b31SStefan Hajnoczi     BdrvTrackedRequest req;
94661007b31SStefan Hajnoczi 
947*d01c07f2SFam Zheng     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
948*d01c07f2SFam Zheng     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
94961007b31SStefan Hajnoczi     uint8_t *head_buf = NULL;
95061007b31SStefan Hajnoczi     uint8_t *tail_buf = NULL;
95161007b31SStefan Hajnoczi     QEMUIOVector local_qiov;
95261007b31SStefan Hajnoczi     bool use_local_qiov = false;
95361007b31SStefan Hajnoczi     int ret;
95461007b31SStefan Hajnoczi 
95561007b31SStefan Hajnoczi     if (!drv) {
95661007b31SStefan Hajnoczi         return -ENOMEDIUM;
95761007b31SStefan Hajnoczi     }
95861007b31SStefan Hajnoczi 
95961007b31SStefan Hajnoczi     ret = bdrv_check_byte_request(bs, offset, bytes);
96061007b31SStefan Hajnoczi     if (ret < 0) {
96161007b31SStefan Hajnoczi         return ret;
96261007b31SStefan Hajnoczi     }
96361007b31SStefan Hajnoczi 
96461007b31SStefan Hajnoczi     if (bs->copy_on_read) {
96561007b31SStefan Hajnoczi         flags |= BDRV_REQ_COPY_ON_READ;
96661007b31SStefan Hajnoczi     }
96761007b31SStefan Hajnoczi 
96861007b31SStefan Hajnoczi     /* throttling disk I/O */
96961007b31SStefan Hajnoczi     if (bs->io_limits_enabled) {
97061007b31SStefan Hajnoczi         bdrv_io_limits_intercept(bs, bytes, false);
97161007b31SStefan Hajnoczi     }
97261007b31SStefan Hajnoczi 
97361007b31SStefan Hajnoczi     /* Align read if necessary by padding qiov */
97461007b31SStefan Hajnoczi     if (offset & (align - 1)) {
97561007b31SStefan Hajnoczi         head_buf = qemu_blockalign(bs, align);
97661007b31SStefan Hajnoczi         qemu_iovec_init(&local_qiov, qiov->niov + 2);
97761007b31SStefan Hajnoczi         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
97861007b31SStefan Hajnoczi         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
97961007b31SStefan Hajnoczi         use_local_qiov = true;
98061007b31SStefan Hajnoczi 
98161007b31SStefan Hajnoczi         bytes += offset & (align - 1);
98261007b31SStefan Hajnoczi         offset = offset & ~(align - 1);
98361007b31SStefan Hajnoczi     }
98461007b31SStefan Hajnoczi 
98561007b31SStefan Hajnoczi     if ((offset + bytes) & (align - 1)) {
98661007b31SStefan Hajnoczi         if (!use_local_qiov) {
98761007b31SStefan Hajnoczi             qemu_iovec_init(&local_qiov, qiov->niov + 1);
98861007b31SStefan Hajnoczi             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
98961007b31SStefan Hajnoczi             use_local_qiov = true;
99061007b31SStefan Hajnoczi         }
99161007b31SStefan Hajnoczi         tail_buf = qemu_blockalign(bs, align);
99261007b31SStefan Hajnoczi         qemu_iovec_add(&local_qiov, tail_buf,
99361007b31SStefan Hajnoczi                        align - ((offset + bytes) & (align - 1)));
99461007b31SStefan Hajnoczi 
99561007b31SStefan Hajnoczi         bytes = ROUND_UP(bytes, align);
99661007b31SStefan Hajnoczi     }
99761007b31SStefan Hajnoczi 
99861007b31SStefan Hajnoczi     tracked_request_begin(&req, bs, offset, bytes, false);
99961007b31SStefan Hajnoczi     ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
100061007b31SStefan Hajnoczi                               use_local_qiov ? &local_qiov : qiov,
100161007b31SStefan Hajnoczi                               flags);
100261007b31SStefan Hajnoczi     tracked_request_end(&req);
100361007b31SStefan Hajnoczi 
100461007b31SStefan Hajnoczi     if (use_local_qiov) {
100561007b31SStefan Hajnoczi         qemu_iovec_destroy(&local_qiov);
100661007b31SStefan Hajnoczi         qemu_vfree(head_buf);
100761007b31SStefan Hajnoczi         qemu_vfree(tail_buf);
100861007b31SStefan Hajnoczi     }
100961007b31SStefan Hajnoczi 
101061007b31SStefan Hajnoczi     return ret;
101161007b31SStefan Hajnoczi }
101261007b31SStefan Hajnoczi 
101361007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
101461007b31SStefan Hajnoczi     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
101561007b31SStefan Hajnoczi     BdrvRequestFlags flags)
101661007b31SStefan Hajnoczi {
101761007b31SStefan Hajnoczi     if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
101861007b31SStefan Hajnoczi         return -EINVAL;
101961007b31SStefan Hajnoczi     }
102061007b31SStefan Hajnoczi 
102161007b31SStefan Hajnoczi     return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
102261007b31SStefan Hajnoczi                              nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
102361007b31SStefan Hajnoczi }
102461007b31SStefan Hajnoczi 
102561007b31SStefan Hajnoczi int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
102661007b31SStefan Hajnoczi     int nb_sectors, QEMUIOVector *qiov)
102761007b31SStefan Hajnoczi {
102861007b31SStefan Hajnoczi     trace_bdrv_co_readv(bs, sector_num, nb_sectors);
102961007b31SStefan Hajnoczi 
103061007b31SStefan Hajnoczi     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
103161007b31SStefan Hajnoczi }
103261007b31SStefan Hajnoczi 
103361007b31SStefan Hajnoczi int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
103461007b31SStefan Hajnoczi     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
103561007b31SStefan Hajnoczi {
103661007b31SStefan Hajnoczi     trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
103761007b31SStefan Hajnoczi 
103861007b31SStefan Hajnoczi     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
103961007b31SStefan Hajnoczi                             BDRV_REQ_COPY_ON_READ);
104061007b31SStefan Hajnoczi }
104161007b31SStefan Hajnoczi 
104261007b31SStefan Hajnoczi #define MAX_WRITE_ZEROES_BOUNCE_BUFFER 32768
104361007b31SStefan Hajnoczi 
104461007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
104561007b31SStefan Hajnoczi     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
104661007b31SStefan Hajnoczi {
104761007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
104861007b31SStefan Hajnoczi     QEMUIOVector qiov;
104961007b31SStefan Hajnoczi     struct iovec iov = {0};
105061007b31SStefan Hajnoczi     int ret = 0;
105161007b31SStefan Hajnoczi 
105261007b31SStefan Hajnoczi     int max_write_zeroes = MIN_NON_ZERO(bs->bl.max_write_zeroes,
105361007b31SStefan Hajnoczi                                         BDRV_REQUEST_MAX_SECTORS);
105461007b31SStefan Hajnoczi 
105561007b31SStefan Hajnoczi     while (nb_sectors > 0 && !ret) {
105661007b31SStefan Hajnoczi         int num = nb_sectors;
105761007b31SStefan Hajnoczi 
105861007b31SStefan Hajnoczi         /* Align request.  Block drivers can expect the "bulk" of the request
105961007b31SStefan Hajnoczi          * to be aligned.
106061007b31SStefan Hajnoczi          */
106161007b31SStefan Hajnoczi         if (bs->bl.write_zeroes_alignment
106261007b31SStefan Hajnoczi             && num > bs->bl.write_zeroes_alignment) {
106361007b31SStefan Hajnoczi             if (sector_num % bs->bl.write_zeroes_alignment != 0) {
106461007b31SStefan Hajnoczi                 /* Make a small request up to the first aligned sector.  */
106561007b31SStefan Hajnoczi                 num = bs->bl.write_zeroes_alignment;
106661007b31SStefan Hajnoczi                 num -= sector_num % bs->bl.write_zeroes_alignment;
106761007b31SStefan Hajnoczi             } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
106861007b31SStefan Hajnoczi                 /* Shorten the request to the last aligned sector.  num cannot
106961007b31SStefan Hajnoczi                  * underflow because num > bs->bl.write_zeroes_alignment.
107061007b31SStefan Hajnoczi                  */
107161007b31SStefan Hajnoczi                 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
107261007b31SStefan Hajnoczi             }
107361007b31SStefan Hajnoczi         }
107461007b31SStefan Hajnoczi 
107561007b31SStefan Hajnoczi         /* limit request size */
107661007b31SStefan Hajnoczi         if (num > max_write_zeroes) {
107761007b31SStefan Hajnoczi             num = max_write_zeroes;
107861007b31SStefan Hajnoczi         }
107961007b31SStefan Hajnoczi 
108061007b31SStefan Hajnoczi         ret = -ENOTSUP;
108161007b31SStefan Hajnoczi         /* First try the efficient write zeroes operation */
108261007b31SStefan Hajnoczi         if (drv->bdrv_co_write_zeroes) {
108361007b31SStefan Hajnoczi             ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
108461007b31SStefan Hajnoczi         }
108561007b31SStefan Hajnoczi 
108661007b31SStefan Hajnoczi         if (ret == -ENOTSUP) {
108761007b31SStefan Hajnoczi             /* Fall back to bounce buffer if write zeroes is unsupported */
108861007b31SStefan Hajnoczi             int max_xfer_len = MIN_NON_ZERO(bs->bl.max_transfer_length,
108961007b31SStefan Hajnoczi                                             MAX_WRITE_ZEROES_BOUNCE_BUFFER);
109061007b31SStefan Hajnoczi             num = MIN(num, max_xfer_len);
109161007b31SStefan Hajnoczi             iov.iov_len = num * BDRV_SECTOR_SIZE;
109261007b31SStefan Hajnoczi             if (iov.iov_base == NULL) {
109361007b31SStefan Hajnoczi                 iov.iov_base = qemu_try_blockalign(bs, num * BDRV_SECTOR_SIZE);
109461007b31SStefan Hajnoczi                 if (iov.iov_base == NULL) {
109561007b31SStefan Hajnoczi                     ret = -ENOMEM;
109661007b31SStefan Hajnoczi                     goto fail;
109761007b31SStefan Hajnoczi                 }
109861007b31SStefan Hajnoczi                 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
109961007b31SStefan Hajnoczi             }
110061007b31SStefan Hajnoczi             qemu_iovec_init_external(&qiov, &iov, 1);
110161007b31SStefan Hajnoczi 
110261007b31SStefan Hajnoczi             ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
110361007b31SStefan Hajnoczi 
110461007b31SStefan Hajnoczi             /* Keep bounce buffer around if it is big enough for all
110561007b31SStefan Hajnoczi              * all future requests.
110661007b31SStefan Hajnoczi              */
110761007b31SStefan Hajnoczi             if (num < max_xfer_len) {
110861007b31SStefan Hajnoczi                 qemu_vfree(iov.iov_base);
110961007b31SStefan Hajnoczi                 iov.iov_base = NULL;
111061007b31SStefan Hajnoczi             }
111161007b31SStefan Hajnoczi         }
111261007b31SStefan Hajnoczi 
111361007b31SStefan Hajnoczi         sector_num += num;
111461007b31SStefan Hajnoczi         nb_sectors -= num;
111561007b31SStefan Hajnoczi     }
111661007b31SStefan Hajnoczi 
111761007b31SStefan Hajnoczi fail:
111861007b31SStefan Hajnoczi     qemu_vfree(iov.iov_base);
111961007b31SStefan Hajnoczi     return ret;
112061007b31SStefan Hajnoczi }
112161007b31SStefan Hajnoczi 
112261007b31SStefan Hajnoczi /*
112361007b31SStefan Hajnoczi  * Forwards an already correctly aligned write request to the BlockDriver.
112461007b31SStefan Hajnoczi  */
112561007b31SStefan Hajnoczi static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
112661007b31SStefan Hajnoczi     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
112761007b31SStefan Hajnoczi     QEMUIOVector *qiov, int flags)
112861007b31SStefan Hajnoczi {
112961007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
113061007b31SStefan Hajnoczi     bool waited;
113161007b31SStefan Hajnoczi     int ret;
113261007b31SStefan Hajnoczi 
113361007b31SStefan Hajnoczi     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
113461007b31SStefan Hajnoczi     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
113561007b31SStefan Hajnoczi 
113661007b31SStefan Hajnoczi     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
113761007b31SStefan Hajnoczi     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
113861007b31SStefan Hajnoczi     assert(!qiov || bytes == qiov->size);
113961007b31SStefan Hajnoczi 
114061007b31SStefan Hajnoczi     waited = wait_serialising_requests(req);
114161007b31SStefan Hajnoczi     assert(!waited || !req->serialising);
114261007b31SStefan Hajnoczi     assert(req->overlap_offset <= offset);
114361007b31SStefan Hajnoczi     assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
114461007b31SStefan Hajnoczi 
114561007b31SStefan Hajnoczi     ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
114661007b31SStefan Hajnoczi 
114761007b31SStefan Hajnoczi     if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
114861007b31SStefan Hajnoczi         !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
114961007b31SStefan Hajnoczi         qemu_iovec_is_zero(qiov)) {
115061007b31SStefan Hajnoczi         flags |= BDRV_REQ_ZERO_WRITE;
115161007b31SStefan Hajnoczi         if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
115261007b31SStefan Hajnoczi             flags |= BDRV_REQ_MAY_UNMAP;
115361007b31SStefan Hajnoczi         }
115461007b31SStefan Hajnoczi     }
115561007b31SStefan Hajnoczi 
115661007b31SStefan Hajnoczi     if (ret < 0) {
115761007b31SStefan Hajnoczi         /* Do nothing, write notifier decided to fail this request */
115861007b31SStefan Hajnoczi     } else if (flags & BDRV_REQ_ZERO_WRITE) {
115961007b31SStefan Hajnoczi         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
116061007b31SStefan Hajnoczi         ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
116161007b31SStefan Hajnoczi     } else {
116261007b31SStefan Hajnoczi         BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
116361007b31SStefan Hajnoczi         ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
116461007b31SStefan Hajnoczi     }
116561007b31SStefan Hajnoczi     BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
116661007b31SStefan Hajnoczi 
116761007b31SStefan Hajnoczi     if (ret == 0 && !bs->enable_write_cache) {
116861007b31SStefan Hajnoczi         ret = bdrv_co_flush(bs);
116961007b31SStefan Hajnoczi     }
117061007b31SStefan Hajnoczi 
117161007b31SStefan Hajnoczi     bdrv_set_dirty(bs, sector_num, nb_sectors);
117261007b31SStefan Hajnoczi 
117361007b31SStefan Hajnoczi     block_acct_highest_sector(&bs->stats, sector_num, nb_sectors);
117461007b31SStefan Hajnoczi 
117561007b31SStefan Hajnoczi     if (ret >= 0) {
117661007b31SStefan Hajnoczi         bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
117761007b31SStefan Hajnoczi     }
117861007b31SStefan Hajnoczi 
117961007b31SStefan Hajnoczi     return ret;
118061007b31SStefan Hajnoczi }
118161007b31SStefan Hajnoczi 
118261007b31SStefan Hajnoczi /*
118361007b31SStefan Hajnoczi  * Handle a write request in coroutine context
118461007b31SStefan Hajnoczi  */
118561007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
118661007b31SStefan Hajnoczi     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
118761007b31SStefan Hajnoczi     BdrvRequestFlags flags)
118861007b31SStefan Hajnoczi {
118961007b31SStefan Hajnoczi     BdrvTrackedRequest req;
1190*d01c07f2SFam Zheng     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
1191*d01c07f2SFam Zheng     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
119261007b31SStefan Hajnoczi     uint8_t *head_buf = NULL;
119361007b31SStefan Hajnoczi     uint8_t *tail_buf = NULL;
119461007b31SStefan Hajnoczi     QEMUIOVector local_qiov;
119561007b31SStefan Hajnoczi     bool use_local_qiov = false;
119661007b31SStefan Hajnoczi     int ret;
119761007b31SStefan Hajnoczi 
119861007b31SStefan Hajnoczi     if (!bs->drv) {
119961007b31SStefan Hajnoczi         return -ENOMEDIUM;
120061007b31SStefan Hajnoczi     }
120161007b31SStefan Hajnoczi     if (bs->read_only) {
1202eaf5fe2dSPaolo Bonzini         return -EPERM;
120361007b31SStefan Hajnoczi     }
120461007b31SStefan Hajnoczi 
120561007b31SStefan Hajnoczi     ret = bdrv_check_byte_request(bs, offset, bytes);
120661007b31SStefan Hajnoczi     if (ret < 0) {
120761007b31SStefan Hajnoczi         return ret;
120861007b31SStefan Hajnoczi     }
120961007b31SStefan Hajnoczi 
121061007b31SStefan Hajnoczi     /* throttling disk I/O */
121161007b31SStefan Hajnoczi     if (bs->io_limits_enabled) {
121261007b31SStefan Hajnoczi         bdrv_io_limits_intercept(bs, bytes, true);
121361007b31SStefan Hajnoczi     }
121461007b31SStefan Hajnoczi 
121561007b31SStefan Hajnoczi     /*
121661007b31SStefan Hajnoczi      * Align write if necessary by performing a read-modify-write cycle.
121761007b31SStefan Hajnoczi      * Pad qiov with the read parts and be sure to have a tracked request not
121861007b31SStefan Hajnoczi      * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
121961007b31SStefan Hajnoczi      */
122061007b31SStefan Hajnoczi     tracked_request_begin(&req, bs, offset, bytes, true);
122161007b31SStefan Hajnoczi 
122261007b31SStefan Hajnoczi     if (offset & (align - 1)) {
122361007b31SStefan Hajnoczi         QEMUIOVector head_qiov;
122461007b31SStefan Hajnoczi         struct iovec head_iov;
122561007b31SStefan Hajnoczi 
122661007b31SStefan Hajnoczi         mark_request_serialising(&req, align);
122761007b31SStefan Hajnoczi         wait_serialising_requests(&req);
122861007b31SStefan Hajnoczi 
122961007b31SStefan Hajnoczi         head_buf = qemu_blockalign(bs, align);
123061007b31SStefan Hajnoczi         head_iov = (struct iovec) {
123161007b31SStefan Hajnoczi             .iov_base   = head_buf,
123261007b31SStefan Hajnoczi             .iov_len    = align,
123361007b31SStefan Hajnoczi         };
123461007b31SStefan Hajnoczi         qemu_iovec_init_external(&head_qiov, &head_iov, 1);
123561007b31SStefan Hajnoczi 
123661007b31SStefan Hajnoczi         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
123761007b31SStefan Hajnoczi         ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
123861007b31SStefan Hajnoczi                                   align, &head_qiov, 0);
123961007b31SStefan Hajnoczi         if (ret < 0) {
124061007b31SStefan Hajnoczi             goto fail;
124161007b31SStefan Hajnoczi         }
124261007b31SStefan Hajnoczi         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
124361007b31SStefan Hajnoczi 
124461007b31SStefan Hajnoczi         qemu_iovec_init(&local_qiov, qiov->niov + 2);
124561007b31SStefan Hajnoczi         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
124661007b31SStefan Hajnoczi         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
124761007b31SStefan Hajnoczi         use_local_qiov = true;
124861007b31SStefan Hajnoczi 
124961007b31SStefan Hajnoczi         bytes += offset & (align - 1);
125061007b31SStefan Hajnoczi         offset = offset & ~(align - 1);
125161007b31SStefan Hajnoczi     }
125261007b31SStefan Hajnoczi 
125361007b31SStefan Hajnoczi     if ((offset + bytes) & (align - 1)) {
125461007b31SStefan Hajnoczi         QEMUIOVector tail_qiov;
125561007b31SStefan Hajnoczi         struct iovec tail_iov;
125661007b31SStefan Hajnoczi         size_t tail_bytes;
125761007b31SStefan Hajnoczi         bool waited;
125861007b31SStefan Hajnoczi 
125961007b31SStefan Hajnoczi         mark_request_serialising(&req, align);
126061007b31SStefan Hajnoczi         waited = wait_serialising_requests(&req);
126161007b31SStefan Hajnoczi         assert(!waited || !use_local_qiov);
126261007b31SStefan Hajnoczi 
126361007b31SStefan Hajnoczi         tail_buf = qemu_blockalign(bs, align);
126461007b31SStefan Hajnoczi         tail_iov = (struct iovec) {
126561007b31SStefan Hajnoczi             .iov_base   = tail_buf,
126661007b31SStefan Hajnoczi             .iov_len    = align,
126761007b31SStefan Hajnoczi         };
126861007b31SStefan Hajnoczi         qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
126961007b31SStefan Hajnoczi 
127061007b31SStefan Hajnoczi         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
127161007b31SStefan Hajnoczi         ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
127261007b31SStefan Hajnoczi                                   align, &tail_qiov, 0);
127361007b31SStefan Hajnoczi         if (ret < 0) {
127461007b31SStefan Hajnoczi             goto fail;
127561007b31SStefan Hajnoczi         }
127661007b31SStefan Hajnoczi         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
127761007b31SStefan Hajnoczi 
127861007b31SStefan Hajnoczi         if (!use_local_qiov) {
127961007b31SStefan Hajnoczi             qemu_iovec_init(&local_qiov, qiov->niov + 1);
128061007b31SStefan Hajnoczi             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
128161007b31SStefan Hajnoczi             use_local_qiov = true;
128261007b31SStefan Hajnoczi         }
128361007b31SStefan Hajnoczi 
128461007b31SStefan Hajnoczi         tail_bytes = (offset + bytes) & (align - 1);
128561007b31SStefan Hajnoczi         qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
128661007b31SStefan Hajnoczi 
128761007b31SStefan Hajnoczi         bytes = ROUND_UP(bytes, align);
128861007b31SStefan Hajnoczi     }
128961007b31SStefan Hajnoczi 
129061007b31SStefan Hajnoczi     ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
129161007b31SStefan Hajnoczi                                use_local_qiov ? &local_qiov : qiov,
129261007b31SStefan Hajnoczi                                flags);
129361007b31SStefan Hajnoczi 
129461007b31SStefan Hajnoczi fail:
129561007b31SStefan Hajnoczi     tracked_request_end(&req);
129661007b31SStefan Hajnoczi 
129761007b31SStefan Hajnoczi     if (use_local_qiov) {
129861007b31SStefan Hajnoczi         qemu_iovec_destroy(&local_qiov);
129961007b31SStefan Hajnoczi     }
130061007b31SStefan Hajnoczi     qemu_vfree(head_buf);
130161007b31SStefan Hajnoczi     qemu_vfree(tail_buf);
130261007b31SStefan Hajnoczi 
130361007b31SStefan Hajnoczi     return ret;
130461007b31SStefan Hajnoczi }
130561007b31SStefan Hajnoczi 
130661007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
130761007b31SStefan Hajnoczi     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
130861007b31SStefan Hajnoczi     BdrvRequestFlags flags)
130961007b31SStefan Hajnoczi {
131061007b31SStefan Hajnoczi     if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
131161007b31SStefan Hajnoczi         return -EINVAL;
131261007b31SStefan Hajnoczi     }
131361007b31SStefan Hajnoczi 
131461007b31SStefan Hajnoczi     return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
131561007b31SStefan Hajnoczi                               nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
131661007b31SStefan Hajnoczi }
131761007b31SStefan Hajnoczi 
131861007b31SStefan Hajnoczi int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
131961007b31SStefan Hajnoczi     int nb_sectors, QEMUIOVector *qiov)
132061007b31SStefan Hajnoczi {
132161007b31SStefan Hajnoczi     trace_bdrv_co_writev(bs, sector_num, nb_sectors);
132261007b31SStefan Hajnoczi 
132361007b31SStefan Hajnoczi     return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
132461007b31SStefan Hajnoczi }
132561007b31SStefan Hajnoczi 
132661007b31SStefan Hajnoczi int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
132761007b31SStefan Hajnoczi                                       int64_t sector_num, int nb_sectors,
132861007b31SStefan Hajnoczi                                       BdrvRequestFlags flags)
132961007b31SStefan Hajnoczi {
133061007b31SStefan Hajnoczi     trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
133161007b31SStefan Hajnoczi 
133261007b31SStefan Hajnoczi     if (!(bs->open_flags & BDRV_O_UNMAP)) {
133361007b31SStefan Hajnoczi         flags &= ~BDRV_REQ_MAY_UNMAP;
133461007b31SStefan Hajnoczi     }
133561007b31SStefan Hajnoczi 
1336*d01c07f2SFam Zheng     return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
133761007b31SStefan Hajnoczi                              BDRV_REQ_ZERO_WRITE | flags);
133861007b31SStefan Hajnoczi }
133961007b31SStefan Hajnoczi 
134061007b31SStefan Hajnoczi int bdrv_flush_all(void)
134161007b31SStefan Hajnoczi {
134261007b31SStefan Hajnoczi     BlockDriverState *bs = NULL;
134361007b31SStefan Hajnoczi     int result = 0;
134461007b31SStefan Hajnoczi 
134561007b31SStefan Hajnoczi     while ((bs = bdrv_next(bs))) {
134661007b31SStefan Hajnoczi         AioContext *aio_context = bdrv_get_aio_context(bs);
134761007b31SStefan Hajnoczi         int ret;
134861007b31SStefan Hajnoczi 
134961007b31SStefan Hajnoczi         aio_context_acquire(aio_context);
135061007b31SStefan Hajnoczi         ret = bdrv_flush(bs);
135161007b31SStefan Hajnoczi         if (ret < 0 && !result) {
135261007b31SStefan Hajnoczi             result = ret;
135361007b31SStefan Hajnoczi         }
135461007b31SStefan Hajnoczi         aio_context_release(aio_context);
135561007b31SStefan Hajnoczi     }
135661007b31SStefan Hajnoczi 
135761007b31SStefan Hajnoczi     return result;
135861007b31SStefan Hajnoczi }
135961007b31SStefan Hajnoczi 
136061007b31SStefan Hajnoczi typedef struct BdrvCoGetBlockStatusData {
136161007b31SStefan Hajnoczi     BlockDriverState *bs;
136261007b31SStefan Hajnoczi     BlockDriverState *base;
136361007b31SStefan Hajnoczi     int64_t sector_num;
136461007b31SStefan Hajnoczi     int nb_sectors;
136561007b31SStefan Hajnoczi     int *pnum;
136661007b31SStefan Hajnoczi     int64_t ret;
136761007b31SStefan Hajnoczi     bool done;
136861007b31SStefan Hajnoczi } BdrvCoGetBlockStatusData;
136961007b31SStefan Hajnoczi 
137061007b31SStefan Hajnoczi /*
137161007b31SStefan Hajnoczi  * Returns the allocation status of the specified sectors.
137261007b31SStefan Hajnoczi  * Drivers not implementing the functionality are assumed to not support
137361007b31SStefan Hajnoczi  * backing files, hence all their sectors are reported as allocated.
137461007b31SStefan Hajnoczi  *
137561007b31SStefan Hajnoczi  * If 'sector_num' is beyond the end of the disk image the return value is 0
137661007b31SStefan Hajnoczi  * and 'pnum' is set to 0.
137761007b31SStefan Hajnoczi  *
137861007b31SStefan Hajnoczi  * 'pnum' is set to the number of sectors (including and immediately following
137961007b31SStefan Hajnoczi  * the specified sector) that are known to be in the same
138061007b31SStefan Hajnoczi  * allocated/unallocated state.
138161007b31SStefan Hajnoczi  *
138261007b31SStefan Hajnoczi  * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
138361007b31SStefan Hajnoczi  * beyond the end of the disk image it will be clamped.
138461007b31SStefan Hajnoczi  */
138561007b31SStefan Hajnoczi static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
138661007b31SStefan Hajnoczi                                                      int64_t sector_num,
138761007b31SStefan Hajnoczi                                                      int nb_sectors, int *pnum)
138861007b31SStefan Hajnoczi {
138961007b31SStefan Hajnoczi     int64_t total_sectors;
139061007b31SStefan Hajnoczi     int64_t n;
139161007b31SStefan Hajnoczi     int64_t ret, ret2;
139261007b31SStefan Hajnoczi 
139361007b31SStefan Hajnoczi     total_sectors = bdrv_nb_sectors(bs);
139461007b31SStefan Hajnoczi     if (total_sectors < 0) {
139561007b31SStefan Hajnoczi         return total_sectors;
139661007b31SStefan Hajnoczi     }
139761007b31SStefan Hajnoczi 
139861007b31SStefan Hajnoczi     if (sector_num >= total_sectors) {
139961007b31SStefan Hajnoczi         *pnum = 0;
140061007b31SStefan Hajnoczi         return 0;
140161007b31SStefan Hajnoczi     }
140261007b31SStefan Hajnoczi 
140361007b31SStefan Hajnoczi     n = total_sectors - sector_num;
140461007b31SStefan Hajnoczi     if (n < nb_sectors) {
140561007b31SStefan Hajnoczi         nb_sectors = n;
140661007b31SStefan Hajnoczi     }
140761007b31SStefan Hajnoczi 
140861007b31SStefan Hajnoczi     if (!bs->drv->bdrv_co_get_block_status) {
140961007b31SStefan Hajnoczi         *pnum = nb_sectors;
141061007b31SStefan Hajnoczi         ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
141161007b31SStefan Hajnoczi         if (bs->drv->protocol_name) {
141261007b31SStefan Hajnoczi             ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
141361007b31SStefan Hajnoczi         }
141461007b31SStefan Hajnoczi         return ret;
141561007b31SStefan Hajnoczi     }
141661007b31SStefan Hajnoczi 
141761007b31SStefan Hajnoczi     ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
141861007b31SStefan Hajnoczi     if (ret < 0) {
141961007b31SStefan Hajnoczi         *pnum = 0;
142061007b31SStefan Hajnoczi         return ret;
142161007b31SStefan Hajnoczi     }
142261007b31SStefan Hajnoczi 
142361007b31SStefan Hajnoczi     if (ret & BDRV_BLOCK_RAW) {
142461007b31SStefan Hajnoczi         assert(ret & BDRV_BLOCK_OFFSET_VALID);
142561007b31SStefan Hajnoczi         return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
142661007b31SStefan Hajnoczi                                      *pnum, pnum);
142761007b31SStefan Hajnoczi     }
142861007b31SStefan Hajnoczi 
142961007b31SStefan Hajnoczi     if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
143061007b31SStefan Hajnoczi         ret |= BDRV_BLOCK_ALLOCATED;
143161007b31SStefan Hajnoczi     }
143261007b31SStefan Hajnoczi 
143361007b31SStefan Hajnoczi     if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
143461007b31SStefan Hajnoczi         if (bdrv_unallocated_blocks_are_zero(bs)) {
143561007b31SStefan Hajnoczi             ret |= BDRV_BLOCK_ZERO;
143661007b31SStefan Hajnoczi         } else if (bs->backing_hd) {
143761007b31SStefan Hajnoczi             BlockDriverState *bs2 = bs->backing_hd;
143861007b31SStefan Hajnoczi             int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
143961007b31SStefan Hajnoczi             if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
144061007b31SStefan Hajnoczi                 ret |= BDRV_BLOCK_ZERO;
144161007b31SStefan Hajnoczi             }
144261007b31SStefan Hajnoczi         }
144361007b31SStefan Hajnoczi     }
144461007b31SStefan Hajnoczi 
144561007b31SStefan Hajnoczi     if (bs->file &&
144661007b31SStefan Hajnoczi         (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
144761007b31SStefan Hajnoczi         (ret & BDRV_BLOCK_OFFSET_VALID)) {
144861007b31SStefan Hajnoczi         int file_pnum;
144961007b31SStefan Hajnoczi 
145061007b31SStefan Hajnoczi         ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
145161007b31SStefan Hajnoczi                                         *pnum, &file_pnum);
145261007b31SStefan Hajnoczi         if (ret2 >= 0) {
145361007b31SStefan Hajnoczi             /* Ignore errors.  This is just providing extra information, it
145461007b31SStefan Hajnoczi              * is useful but not necessary.
145561007b31SStefan Hajnoczi              */
145661007b31SStefan Hajnoczi             if (!file_pnum) {
145761007b31SStefan Hajnoczi                 /* !file_pnum indicates an offset at or beyond the EOF; it is
145861007b31SStefan Hajnoczi                  * perfectly valid for the format block driver to point to such
145961007b31SStefan Hajnoczi                  * offsets, so catch it and mark everything as zero */
146061007b31SStefan Hajnoczi                 ret |= BDRV_BLOCK_ZERO;
146161007b31SStefan Hajnoczi             } else {
146261007b31SStefan Hajnoczi                 /* Limit request to the range reported by the protocol driver */
146361007b31SStefan Hajnoczi                 *pnum = file_pnum;
146461007b31SStefan Hajnoczi                 ret |= (ret2 & BDRV_BLOCK_ZERO);
146561007b31SStefan Hajnoczi             }
146661007b31SStefan Hajnoczi         }
146761007b31SStefan Hajnoczi     }
146861007b31SStefan Hajnoczi 
146961007b31SStefan Hajnoczi     return ret;
147061007b31SStefan Hajnoczi }
147161007b31SStefan Hajnoczi 
147261007b31SStefan Hajnoczi /* Coroutine wrapper for bdrv_get_block_status() */
147361007b31SStefan Hajnoczi static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
147461007b31SStefan Hajnoczi {
147561007b31SStefan Hajnoczi     BdrvCoGetBlockStatusData *data = opaque;
147661007b31SStefan Hajnoczi     BlockDriverState *bs = data->bs;
147761007b31SStefan Hajnoczi 
147861007b31SStefan Hajnoczi     data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
147961007b31SStefan Hajnoczi                                          data->pnum);
148061007b31SStefan Hajnoczi     data->done = true;
148161007b31SStefan Hajnoczi }
148261007b31SStefan Hajnoczi 
148361007b31SStefan Hajnoczi /*
148461007b31SStefan Hajnoczi  * Synchronous wrapper around bdrv_co_get_block_status().
148561007b31SStefan Hajnoczi  *
148661007b31SStefan Hajnoczi  * See bdrv_co_get_block_status() for details.
148761007b31SStefan Hajnoczi  */
148861007b31SStefan Hajnoczi int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
148961007b31SStefan Hajnoczi                               int nb_sectors, int *pnum)
149061007b31SStefan Hajnoczi {
149161007b31SStefan Hajnoczi     Coroutine *co;
149261007b31SStefan Hajnoczi     BdrvCoGetBlockStatusData data = {
149361007b31SStefan Hajnoczi         .bs = bs,
149461007b31SStefan Hajnoczi         .sector_num = sector_num,
149561007b31SStefan Hajnoczi         .nb_sectors = nb_sectors,
149661007b31SStefan Hajnoczi         .pnum = pnum,
149761007b31SStefan Hajnoczi         .done = false,
149861007b31SStefan Hajnoczi     };
149961007b31SStefan Hajnoczi 
150061007b31SStefan Hajnoczi     if (qemu_in_coroutine()) {
150161007b31SStefan Hajnoczi         /* Fast-path if already in coroutine context */
150261007b31SStefan Hajnoczi         bdrv_get_block_status_co_entry(&data);
150361007b31SStefan Hajnoczi     } else {
150461007b31SStefan Hajnoczi         AioContext *aio_context = bdrv_get_aio_context(bs);
150561007b31SStefan Hajnoczi 
150661007b31SStefan Hajnoczi         co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
150761007b31SStefan Hajnoczi         qemu_coroutine_enter(co, &data);
150861007b31SStefan Hajnoczi         while (!data.done) {
150961007b31SStefan Hajnoczi             aio_poll(aio_context, true);
151061007b31SStefan Hajnoczi         }
151161007b31SStefan Hajnoczi     }
151261007b31SStefan Hajnoczi     return data.ret;
151361007b31SStefan Hajnoczi }
151461007b31SStefan Hajnoczi 
151561007b31SStefan Hajnoczi int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
151661007b31SStefan Hajnoczi                                    int nb_sectors, int *pnum)
151761007b31SStefan Hajnoczi {
151861007b31SStefan Hajnoczi     int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
151961007b31SStefan Hajnoczi     if (ret < 0) {
152061007b31SStefan Hajnoczi         return ret;
152161007b31SStefan Hajnoczi     }
152261007b31SStefan Hajnoczi     return !!(ret & BDRV_BLOCK_ALLOCATED);
152361007b31SStefan Hajnoczi }
152461007b31SStefan Hajnoczi 
152561007b31SStefan Hajnoczi /*
152661007b31SStefan Hajnoczi  * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
152761007b31SStefan Hajnoczi  *
152861007b31SStefan Hajnoczi  * Return true if the given sector is allocated in any image between
152961007b31SStefan Hajnoczi  * BASE and TOP (inclusive).  BASE can be NULL to check if the given
153061007b31SStefan Hajnoczi  * sector is allocated in any image of the chain.  Return false otherwise.
153161007b31SStefan Hajnoczi  *
153261007b31SStefan Hajnoczi  * 'pnum' is set to the number of sectors (including and immediately following
153361007b31SStefan Hajnoczi  *  the specified sector) that are known to be in the same
153461007b31SStefan Hajnoczi  *  allocated/unallocated state.
153561007b31SStefan Hajnoczi  *
153661007b31SStefan Hajnoczi  */
153761007b31SStefan Hajnoczi int bdrv_is_allocated_above(BlockDriverState *top,
153861007b31SStefan Hajnoczi                             BlockDriverState *base,
153961007b31SStefan Hajnoczi                             int64_t sector_num,
154061007b31SStefan Hajnoczi                             int nb_sectors, int *pnum)
154161007b31SStefan Hajnoczi {
154261007b31SStefan Hajnoczi     BlockDriverState *intermediate;
154361007b31SStefan Hajnoczi     int ret, n = nb_sectors;
154461007b31SStefan Hajnoczi 
154561007b31SStefan Hajnoczi     intermediate = top;
154661007b31SStefan Hajnoczi     while (intermediate && intermediate != base) {
154761007b31SStefan Hajnoczi         int pnum_inter;
154861007b31SStefan Hajnoczi         ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
154961007b31SStefan Hajnoczi                                 &pnum_inter);
155061007b31SStefan Hajnoczi         if (ret < 0) {
155161007b31SStefan Hajnoczi             return ret;
155261007b31SStefan Hajnoczi         } else if (ret) {
155361007b31SStefan Hajnoczi             *pnum = pnum_inter;
155461007b31SStefan Hajnoczi             return 1;
155561007b31SStefan Hajnoczi         }
155661007b31SStefan Hajnoczi 
155761007b31SStefan Hajnoczi         /*
155861007b31SStefan Hajnoczi          * [sector_num, nb_sectors] is unallocated on top but intermediate
155961007b31SStefan Hajnoczi          * might have
156061007b31SStefan Hajnoczi          *
156161007b31SStefan Hajnoczi          * [sector_num+x, nr_sectors] allocated.
156261007b31SStefan Hajnoczi          */
156361007b31SStefan Hajnoczi         if (n > pnum_inter &&
156461007b31SStefan Hajnoczi             (intermediate == top ||
156561007b31SStefan Hajnoczi              sector_num + pnum_inter < intermediate->total_sectors)) {
156661007b31SStefan Hajnoczi             n = pnum_inter;
156761007b31SStefan Hajnoczi         }
156861007b31SStefan Hajnoczi 
156961007b31SStefan Hajnoczi         intermediate = intermediate->backing_hd;
157061007b31SStefan Hajnoczi     }
157161007b31SStefan Hajnoczi 
157261007b31SStefan Hajnoczi     *pnum = n;
157361007b31SStefan Hajnoczi     return 0;
157461007b31SStefan Hajnoczi }
157561007b31SStefan Hajnoczi 
157661007b31SStefan Hajnoczi int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
157761007b31SStefan Hajnoczi                           const uint8_t *buf, int nb_sectors)
157861007b31SStefan Hajnoczi {
157961007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
158061007b31SStefan Hajnoczi     int ret;
158161007b31SStefan Hajnoczi 
158261007b31SStefan Hajnoczi     if (!drv) {
158361007b31SStefan Hajnoczi         return -ENOMEDIUM;
158461007b31SStefan Hajnoczi     }
158561007b31SStefan Hajnoczi     if (!drv->bdrv_write_compressed) {
158661007b31SStefan Hajnoczi         return -ENOTSUP;
158761007b31SStefan Hajnoczi     }
158861007b31SStefan Hajnoczi     ret = bdrv_check_request(bs, sector_num, nb_sectors);
158961007b31SStefan Hajnoczi     if (ret < 0) {
159061007b31SStefan Hajnoczi         return ret;
159161007b31SStefan Hajnoczi     }
159261007b31SStefan Hajnoczi 
159361007b31SStefan Hajnoczi     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
159461007b31SStefan Hajnoczi 
159561007b31SStefan Hajnoczi     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
159661007b31SStefan Hajnoczi }
159761007b31SStefan Hajnoczi 
159861007b31SStefan Hajnoczi int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
159961007b31SStefan Hajnoczi                       int64_t pos, int size)
160061007b31SStefan Hajnoczi {
160161007b31SStefan Hajnoczi     QEMUIOVector qiov;
160261007b31SStefan Hajnoczi     struct iovec iov = {
160361007b31SStefan Hajnoczi         .iov_base   = (void *) buf,
160461007b31SStefan Hajnoczi         .iov_len    = size,
160561007b31SStefan Hajnoczi     };
160661007b31SStefan Hajnoczi 
160761007b31SStefan Hajnoczi     qemu_iovec_init_external(&qiov, &iov, 1);
160861007b31SStefan Hajnoczi     return bdrv_writev_vmstate(bs, &qiov, pos);
160961007b31SStefan Hajnoczi }
161061007b31SStefan Hajnoczi 
161161007b31SStefan Hajnoczi int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
161261007b31SStefan Hajnoczi {
161361007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
161461007b31SStefan Hajnoczi 
161561007b31SStefan Hajnoczi     if (!drv) {
161661007b31SStefan Hajnoczi         return -ENOMEDIUM;
161761007b31SStefan Hajnoczi     } else if (drv->bdrv_save_vmstate) {
161861007b31SStefan Hajnoczi         return drv->bdrv_save_vmstate(bs, qiov, pos);
161961007b31SStefan Hajnoczi     } else if (bs->file) {
162061007b31SStefan Hajnoczi         return bdrv_writev_vmstate(bs->file, qiov, pos);
162161007b31SStefan Hajnoczi     }
162261007b31SStefan Hajnoczi 
162361007b31SStefan Hajnoczi     return -ENOTSUP;
162461007b31SStefan Hajnoczi }
162561007b31SStefan Hajnoczi 
162661007b31SStefan Hajnoczi int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
162761007b31SStefan Hajnoczi                       int64_t pos, int size)
162861007b31SStefan Hajnoczi {
162961007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
163061007b31SStefan Hajnoczi     if (!drv)
163161007b31SStefan Hajnoczi         return -ENOMEDIUM;
163261007b31SStefan Hajnoczi     if (drv->bdrv_load_vmstate)
163361007b31SStefan Hajnoczi         return drv->bdrv_load_vmstate(bs, buf, pos, size);
163461007b31SStefan Hajnoczi     if (bs->file)
163561007b31SStefan Hajnoczi         return bdrv_load_vmstate(bs->file, buf, pos, size);
163661007b31SStefan Hajnoczi     return -ENOTSUP;
163761007b31SStefan Hajnoczi }
163861007b31SStefan Hajnoczi 
163961007b31SStefan Hajnoczi /**************************************************************/
164061007b31SStefan Hajnoczi /* async I/Os */
164161007b31SStefan Hajnoczi 
164261007b31SStefan Hajnoczi BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
164361007b31SStefan Hajnoczi                            QEMUIOVector *qiov, int nb_sectors,
164461007b31SStefan Hajnoczi                            BlockCompletionFunc *cb, void *opaque)
164561007b31SStefan Hajnoczi {
164661007b31SStefan Hajnoczi     trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
164761007b31SStefan Hajnoczi 
164861007b31SStefan Hajnoczi     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
164961007b31SStefan Hajnoczi                                  cb, opaque, false);
165061007b31SStefan Hajnoczi }
165161007b31SStefan Hajnoczi 
165261007b31SStefan Hajnoczi BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
165361007b31SStefan Hajnoczi                             QEMUIOVector *qiov, int nb_sectors,
165461007b31SStefan Hajnoczi                             BlockCompletionFunc *cb, void *opaque)
165561007b31SStefan Hajnoczi {
165661007b31SStefan Hajnoczi     trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
165761007b31SStefan Hajnoczi 
165861007b31SStefan Hajnoczi     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
165961007b31SStefan Hajnoczi                                  cb, opaque, true);
166061007b31SStefan Hajnoczi }
166161007b31SStefan Hajnoczi 
166261007b31SStefan Hajnoczi BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
166361007b31SStefan Hajnoczi         int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
166461007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque)
166561007b31SStefan Hajnoczi {
166661007b31SStefan Hajnoczi     trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
166761007b31SStefan Hajnoczi 
166861007b31SStefan Hajnoczi     return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
166961007b31SStefan Hajnoczi                                  BDRV_REQ_ZERO_WRITE | flags,
167061007b31SStefan Hajnoczi                                  cb, opaque, true);
167161007b31SStefan Hajnoczi }
167261007b31SStefan Hajnoczi 
167361007b31SStefan Hajnoczi 
167461007b31SStefan Hajnoczi typedef struct MultiwriteCB {
167561007b31SStefan Hajnoczi     int error;
167661007b31SStefan Hajnoczi     int num_requests;
167761007b31SStefan Hajnoczi     int num_callbacks;
167861007b31SStefan Hajnoczi     struct {
167961007b31SStefan Hajnoczi         BlockCompletionFunc *cb;
168061007b31SStefan Hajnoczi         void *opaque;
168161007b31SStefan Hajnoczi         QEMUIOVector *free_qiov;
168261007b31SStefan Hajnoczi     } callbacks[];
168361007b31SStefan Hajnoczi } MultiwriteCB;
168461007b31SStefan Hajnoczi 
168561007b31SStefan Hajnoczi static void multiwrite_user_cb(MultiwriteCB *mcb)
168661007b31SStefan Hajnoczi {
168761007b31SStefan Hajnoczi     int i;
168861007b31SStefan Hajnoczi 
168961007b31SStefan Hajnoczi     for (i = 0; i < mcb->num_callbacks; i++) {
169061007b31SStefan Hajnoczi         mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
169161007b31SStefan Hajnoczi         if (mcb->callbacks[i].free_qiov) {
169261007b31SStefan Hajnoczi             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
169361007b31SStefan Hajnoczi         }
169461007b31SStefan Hajnoczi         g_free(mcb->callbacks[i].free_qiov);
169561007b31SStefan Hajnoczi     }
169661007b31SStefan Hajnoczi }
169761007b31SStefan Hajnoczi 
169861007b31SStefan Hajnoczi static void multiwrite_cb(void *opaque, int ret)
169961007b31SStefan Hajnoczi {
170061007b31SStefan Hajnoczi     MultiwriteCB *mcb = opaque;
170161007b31SStefan Hajnoczi 
170261007b31SStefan Hajnoczi     trace_multiwrite_cb(mcb, ret);
170361007b31SStefan Hajnoczi 
170461007b31SStefan Hajnoczi     if (ret < 0 && !mcb->error) {
170561007b31SStefan Hajnoczi         mcb->error = ret;
170661007b31SStefan Hajnoczi     }
170761007b31SStefan Hajnoczi 
170861007b31SStefan Hajnoczi     mcb->num_requests--;
170961007b31SStefan Hajnoczi     if (mcb->num_requests == 0) {
171061007b31SStefan Hajnoczi         multiwrite_user_cb(mcb);
171161007b31SStefan Hajnoczi         g_free(mcb);
171261007b31SStefan Hajnoczi     }
171361007b31SStefan Hajnoczi }
171461007b31SStefan Hajnoczi 
171561007b31SStefan Hajnoczi static int multiwrite_req_compare(const void *a, const void *b)
171661007b31SStefan Hajnoczi {
171761007b31SStefan Hajnoczi     const BlockRequest *req1 = a, *req2 = b;
171861007b31SStefan Hajnoczi 
171961007b31SStefan Hajnoczi     /*
172061007b31SStefan Hajnoczi      * Note that we can't simply subtract req2->sector from req1->sector
172161007b31SStefan Hajnoczi      * here as that could overflow the return value.
172261007b31SStefan Hajnoczi      */
172361007b31SStefan Hajnoczi     if (req1->sector > req2->sector) {
172461007b31SStefan Hajnoczi         return 1;
172561007b31SStefan Hajnoczi     } else if (req1->sector < req2->sector) {
172661007b31SStefan Hajnoczi         return -1;
172761007b31SStefan Hajnoczi     } else {
172861007b31SStefan Hajnoczi         return 0;
172961007b31SStefan Hajnoczi     }
173061007b31SStefan Hajnoczi }
173161007b31SStefan Hajnoczi 
173261007b31SStefan Hajnoczi /*
173361007b31SStefan Hajnoczi  * Takes a bunch of requests and tries to merge them. Returns the number of
173461007b31SStefan Hajnoczi  * requests that remain after merging.
173561007b31SStefan Hajnoczi  */
173661007b31SStefan Hajnoczi static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
173761007b31SStefan Hajnoczi     int num_reqs, MultiwriteCB *mcb)
173861007b31SStefan Hajnoczi {
173961007b31SStefan Hajnoczi     int i, outidx;
174061007b31SStefan Hajnoczi 
174161007b31SStefan Hajnoczi     // Sort requests by start sector
174261007b31SStefan Hajnoczi     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
174361007b31SStefan Hajnoczi 
174461007b31SStefan Hajnoczi     // Check if adjacent requests touch the same clusters. If so, combine them,
174561007b31SStefan Hajnoczi     // filling up gaps with zero sectors.
174661007b31SStefan Hajnoczi     outidx = 0;
174761007b31SStefan Hajnoczi     for (i = 1; i < num_reqs; i++) {
174861007b31SStefan Hajnoczi         int merge = 0;
174961007b31SStefan Hajnoczi         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
175061007b31SStefan Hajnoczi 
175161007b31SStefan Hajnoczi         // Handle exactly sequential writes and overlapping writes.
175261007b31SStefan Hajnoczi         if (reqs[i].sector <= oldreq_last) {
175361007b31SStefan Hajnoczi             merge = 1;
175461007b31SStefan Hajnoczi         }
175561007b31SStefan Hajnoczi 
175661007b31SStefan Hajnoczi         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
175761007b31SStefan Hajnoczi             merge = 0;
175861007b31SStefan Hajnoczi         }
175961007b31SStefan Hajnoczi 
176061007b31SStefan Hajnoczi         if (bs->bl.max_transfer_length && reqs[outidx].nb_sectors +
176161007b31SStefan Hajnoczi             reqs[i].nb_sectors > bs->bl.max_transfer_length) {
176261007b31SStefan Hajnoczi             merge = 0;
176361007b31SStefan Hajnoczi         }
176461007b31SStefan Hajnoczi 
176561007b31SStefan Hajnoczi         if (merge) {
176661007b31SStefan Hajnoczi             size_t size;
176761007b31SStefan Hajnoczi             QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
176861007b31SStefan Hajnoczi             qemu_iovec_init(qiov,
176961007b31SStefan Hajnoczi                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
177061007b31SStefan Hajnoczi 
177161007b31SStefan Hajnoczi             // Add the first request to the merged one. If the requests are
177261007b31SStefan Hajnoczi             // overlapping, drop the last sectors of the first request.
177361007b31SStefan Hajnoczi             size = (reqs[i].sector - reqs[outidx].sector) << 9;
177461007b31SStefan Hajnoczi             qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
177561007b31SStefan Hajnoczi 
177661007b31SStefan Hajnoczi             // We should need to add any zeros between the two requests
177761007b31SStefan Hajnoczi             assert (reqs[i].sector <= oldreq_last);
177861007b31SStefan Hajnoczi 
177961007b31SStefan Hajnoczi             // Add the second request
178061007b31SStefan Hajnoczi             qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
178161007b31SStefan Hajnoczi 
178261007b31SStefan Hajnoczi             // Add tail of first request, if necessary
178361007b31SStefan Hajnoczi             if (qiov->size < reqs[outidx].qiov->size) {
178461007b31SStefan Hajnoczi                 qemu_iovec_concat(qiov, reqs[outidx].qiov, qiov->size,
178561007b31SStefan Hajnoczi                                   reqs[outidx].qiov->size - qiov->size);
178661007b31SStefan Hajnoczi             }
178761007b31SStefan Hajnoczi 
178861007b31SStefan Hajnoczi             reqs[outidx].nb_sectors = qiov->size >> 9;
178961007b31SStefan Hajnoczi             reqs[outidx].qiov = qiov;
179061007b31SStefan Hajnoczi 
179161007b31SStefan Hajnoczi             mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
179261007b31SStefan Hajnoczi         } else {
179361007b31SStefan Hajnoczi             outidx++;
179461007b31SStefan Hajnoczi             reqs[outidx].sector     = reqs[i].sector;
179561007b31SStefan Hajnoczi             reqs[outidx].nb_sectors = reqs[i].nb_sectors;
179661007b31SStefan Hajnoczi             reqs[outidx].qiov       = reqs[i].qiov;
179761007b31SStefan Hajnoczi         }
179861007b31SStefan Hajnoczi     }
179961007b31SStefan Hajnoczi 
180061007b31SStefan Hajnoczi     block_acct_merge_done(&bs->stats, BLOCK_ACCT_WRITE, num_reqs - outidx - 1);
180161007b31SStefan Hajnoczi 
180261007b31SStefan Hajnoczi     return outidx + 1;
180361007b31SStefan Hajnoczi }
180461007b31SStefan Hajnoczi 
180561007b31SStefan Hajnoczi /*
180661007b31SStefan Hajnoczi  * Submit multiple AIO write requests at once.
180761007b31SStefan Hajnoczi  *
180861007b31SStefan Hajnoczi  * On success, the function returns 0 and all requests in the reqs array have
180961007b31SStefan Hajnoczi  * been submitted. In error case this function returns -1, and any of the
181061007b31SStefan Hajnoczi  * requests may or may not be submitted yet. In particular, this means that the
181161007b31SStefan Hajnoczi  * callback will be called for some of the requests, for others it won't. The
181261007b31SStefan Hajnoczi  * caller must check the error field of the BlockRequest to wait for the right
181361007b31SStefan Hajnoczi  * callbacks (if error != 0, no callback will be called).
181461007b31SStefan Hajnoczi  *
181561007b31SStefan Hajnoczi  * The implementation may modify the contents of the reqs array, e.g. to merge
181661007b31SStefan Hajnoczi  * requests. However, the fields opaque and error are left unmodified as they
181761007b31SStefan Hajnoczi  * are used to signal failure for a single request to the caller.
181861007b31SStefan Hajnoczi  */
181961007b31SStefan Hajnoczi int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
182061007b31SStefan Hajnoczi {
182161007b31SStefan Hajnoczi     MultiwriteCB *mcb;
182261007b31SStefan Hajnoczi     int i;
182361007b31SStefan Hajnoczi 
182461007b31SStefan Hajnoczi     /* don't submit writes if we don't have a medium */
182561007b31SStefan Hajnoczi     if (bs->drv == NULL) {
182661007b31SStefan Hajnoczi         for (i = 0; i < num_reqs; i++) {
182761007b31SStefan Hajnoczi             reqs[i].error = -ENOMEDIUM;
182861007b31SStefan Hajnoczi         }
182961007b31SStefan Hajnoczi         return -1;
183061007b31SStefan Hajnoczi     }
183161007b31SStefan Hajnoczi 
183261007b31SStefan Hajnoczi     if (num_reqs == 0) {
183361007b31SStefan Hajnoczi         return 0;
183461007b31SStefan Hajnoczi     }
183561007b31SStefan Hajnoczi 
183661007b31SStefan Hajnoczi     // Create MultiwriteCB structure
183761007b31SStefan Hajnoczi     mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
183861007b31SStefan Hajnoczi     mcb->num_requests = 0;
183961007b31SStefan Hajnoczi     mcb->num_callbacks = num_reqs;
184061007b31SStefan Hajnoczi 
184161007b31SStefan Hajnoczi     for (i = 0; i < num_reqs; i++) {
184261007b31SStefan Hajnoczi         mcb->callbacks[i].cb = reqs[i].cb;
184361007b31SStefan Hajnoczi         mcb->callbacks[i].opaque = reqs[i].opaque;
184461007b31SStefan Hajnoczi     }
184561007b31SStefan Hajnoczi 
184661007b31SStefan Hajnoczi     // Check for mergable requests
184761007b31SStefan Hajnoczi     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
184861007b31SStefan Hajnoczi 
184961007b31SStefan Hajnoczi     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
185061007b31SStefan Hajnoczi 
185161007b31SStefan Hajnoczi     /* Run the aio requests. */
185261007b31SStefan Hajnoczi     mcb->num_requests = num_reqs;
185361007b31SStefan Hajnoczi     for (i = 0; i < num_reqs; i++) {
185461007b31SStefan Hajnoczi         bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
185561007b31SStefan Hajnoczi                               reqs[i].nb_sectors, reqs[i].flags,
185661007b31SStefan Hajnoczi                               multiwrite_cb, mcb,
185761007b31SStefan Hajnoczi                               true);
185861007b31SStefan Hajnoczi     }
185961007b31SStefan Hajnoczi 
186061007b31SStefan Hajnoczi     return 0;
186161007b31SStefan Hajnoczi }
186261007b31SStefan Hajnoczi 
186361007b31SStefan Hajnoczi void bdrv_aio_cancel(BlockAIOCB *acb)
186461007b31SStefan Hajnoczi {
186561007b31SStefan Hajnoczi     qemu_aio_ref(acb);
186661007b31SStefan Hajnoczi     bdrv_aio_cancel_async(acb);
186761007b31SStefan Hajnoczi     while (acb->refcnt > 1) {
186861007b31SStefan Hajnoczi         if (acb->aiocb_info->get_aio_context) {
186961007b31SStefan Hajnoczi             aio_poll(acb->aiocb_info->get_aio_context(acb), true);
187061007b31SStefan Hajnoczi         } else if (acb->bs) {
187161007b31SStefan Hajnoczi             aio_poll(bdrv_get_aio_context(acb->bs), true);
187261007b31SStefan Hajnoczi         } else {
187361007b31SStefan Hajnoczi             abort();
187461007b31SStefan Hajnoczi         }
187561007b31SStefan Hajnoczi     }
187661007b31SStefan Hajnoczi     qemu_aio_unref(acb);
187761007b31SStefan Hajnoczi }
187861007b31SStefan Hajnoczi 
187961007b31SStefan Hajnoczi /* Async version of aio cancel. The caller is not blocked if the acb implements
188061007b31SStefan Hajnoczi  * cancel_async, otherwise we do nothing and let the request normally complete.
188161007b31SStefan Hajnoczi  * In either case the completion callback must be called. */
188261007b31SStefan Hajnoczi void bdrv_aio_cancel_async(BlockAIOCB *acb)
188361007b31SStefan Hajnoczi {
188461007b31SStefan Hajnoczi     if (acb->aiocb_info->cancel_async) {
188561007b31SStefan Hajnoczi         acb->aiocb_info->cancel_async(acb);
188661007b31SStefan Hajnoczi     }
188761007b31SStefan Hajnoczi }
188861007b31SStefan Hajnoczi 
188961007b31SStefan Hajnoczi /**************************************************************/
189061007b31SStefan Hajnoczi /* async block device emulation */
189161007b31SStefan Hajnoczi 
189261007b31SStefan Hajnoczi typedef struct BlockAIOCBSync {
189361007b31SStefan Hajnoczi     BlockAIOCB common;
189461007b31SStefan Hajnoczi     QEMUBH *bh;
189561007b31SStefan Hajnoczi     int ret;
189661007b31SStefan Hajnoczi     /* vector translation state */
189761007b31SStefan Hajnoczi     QEMUIOVector *qiov;
189861007b31SStefan Hajnoczi     uint8_t *bounce;
189961007b31SStefan Hajnoczi     int is_write;
190061007b31SStefan Hajnoczi } BlockAIOCBSync;
190161007b31SStefan Hajnoczi 
190261007b31SStefan Hajnoczi static const AIOCBInfo bdrv_em_aiocb_info = {
190361007b31SStefan Hajnoczi     .aiocb_size         = sizeof(BlockAIOCBSync),
190461007b31SStefan Hajnoczi };
190561007b31SStefan Hajnoczi 
190661007b31SStefan Hajnoczi static void bdrv_aio_bh_cb(void *opaque)
190761007b31SStefan Hajnoczi {
190861007b31SStefan Hajnoczi     BlockAIOCBSync *acb = opaque;
190961007b31SStefan Hajnoczi 
191061007b31SStefan Hajnoczi     if (!acb->is_write && acb->ret >= 0) {
191161007b31SStefan Hajnoczi         qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
191261007b31SStefan Hajnoczi     }
191361007b31SStefan Hajnoczi     qemu_vfree(acb->bounce);
191461007b31SStefan Hajnoczi     acb->common.cb(acb->common.opaque, acb->ret);
191561007b31SStefan Hajnoczi     qemu_bh_delete(acb->bh);
191661007b31SStefan Hajnoczi     acb->bh = NULL;
191761007b31SStefan Hajnoczi     qemu_aio_unref(acb);
191861007b31SStefan Hajnoczi }
191961007b31SStefan Hajnoczi 
192061007b31SStefan Hajnoczi static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
192161007b31SStefan Hajnoczi                                       int64_t sector_num,
192261007b31SStefan Hajnoczi                                       QEMUIOVector *qiov,
192361007b31SStefan Hajnoczi                                       int nb_sectors,
192461007b31SStefan Hajnoczi                                       BlockCompletionFunc *cb,
192561007b31SStefan Hajnoczi                                       void *opaque,
192661007b31SStefan Hajnoczi                                       int is_write)
192761007b31SStefan Hajnoczi 
192861007b31SStefan Hajnoczi {
192961007b31SStefan Hajnoczi     BlockAIOCBSync *acb;
193061007b31SStefan Hajnoczi 
193161007b31SStefan Hajnoczi     acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
193261007b31SStefan Hajnoczi     acb->is_write = is_write;
193361007b31SStefan Hajnoczi     acb->qiov = qiov;
193461007b31SStefan Hajnoczi     acb->bounce = qemu_try_blockalign(bs, qiov->size);
193561007b31SStefan Hajnoczi     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
193661007b31SStefan Hajnoczi 
193761007b31SStefan Hajnoczi     if (acb->bounce == NULL) {
193861007b31SStefan Hajnoczi         acb->ret = -ENOMEM;
193961007b31SStefan Hajnoczi     } else if (is_write) {
194061007b31SStefan Hajnoczi         qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
194161007b31SStefan Hajnoczi         acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
194261007b31SStefan Hajnoczi     } else {
194361007b31SStefan Hajnoczi         acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
194461007b31SStefan Hajnoczi     }
194561007b31SStefan Hajnoczi 
194661007b31SStefan Hajnoczi     qemu_bh_schedule(acb->bh);
194761007b31SStefan Hajnoczi 
194861007b31SStefan Hajnoczi     return &acb->common;
194961007b31SStefan Hajnoczi }
195061007b31SStefan Hajnoczi 
195161007b31SStefan Hajnoczi static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
195261007b31SStefan Hajnoczi         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
195361007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque)
195461007b31SStefan Hajnoczi {
195561007b31SStefan Hajnoczi     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
195661007b31SStefan Hajnoczi }
195761007b31SStefan Hajnoczi 
195861007b31SStefan Hajnoczi static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
195961007b31SStefan Hajnoczi         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
196061007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque)
196161007b31SStefan Hajnoczi {
196261007b31SStefan Hajnoczi     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
196361007b31SStefan Hajnoczi }
196461007b31SStefan Hajnoczi 
196561007b31SStefan Hajnoczi 
196661007b31SStefan Hajnoczi typedef struct BlockAIOCBCoroutine {
196761007b31SStefan Hajnoczi     BlockAIOCB common;
196861007b31SStefan Hajnoczi     BlockRequest req;
196961007b31SStefan Hajnoczi     bool is_write;
197061007b31SStefan Hajnoczi     bool need_bh;
197161007b31SStefan Hajnoczi     bool *done;
197261007b31SStefan Hajnoczi     QEMUBH* bh;
197361007b31SStefan Hajnoczi } BlockAIOCBCoroutine;
197461007b31SStefan Hajnoczi 
197561007b31SStefan Hajnoczi static const AIOCBInfo bdrv_em_co_aiocb_info = {
197661007b31SStefan Hajnoczi     .aiocb_size         = sizeof(BlockAIOCBCoroutine),
197761007b31SStefan Hajnoczi };
197861007b31SStefan Hajnoczi 
197961007b31SStefan Hajnoczi static void bdrv_co_complete(BlockAIOCBCoroutine *acb)
198061007b31SStefan Hajnoczi {
198161007b31SStefan Hajnoczi     if (!acb->need_bh) {
198261007b31SStefan Hajnoczi         acb->common.cb(acb->common.opaque, acb->req.error);
198361007b31SStefan Hajnoczi         qemu_aio_unref(acb);
198461007b31SStefan Hajnoczi     }
198561007b31SStefan Hajnoczi }
198661007b31SStefan Hajnoczi 
198761007b31SStefan Hajnoczi static void bdrv_co_em_bh(void *opaque)
198861007b31SStefan Hajnoczi {
198961007b31SStefan Hajnoczi     BlockAIOCBCoroutine *acb = opaque;
199061007b31SStefan Hajnoczi 
199161007b31SStefan Hajnoczi     assert(!acb->need_bh);
199261007b31SStefan Hajnoczi     qemu_bh_delete(acb->bh);
199361007b31SStefan Hajnoczi     bdrv_co_complete(acb);
199461007b31SStefan Hajnoczi }
199561007b31SStefan Hajnoczi 
199661007b31SStefan Hajnoczi static void bdrv_co_maybe_schedule_bh(BlockAIOCBCoroutine *acb)
199761007b31SStefan Hajnoczi {
199861007b31SStefan Hajnoczi     acb->need_bh = false;
199961007b31SStefan Hajnoczi     if (acb->req.error != -EINPROGRESS) {
200061007b31SStefan Hajnoczi         BlockDriverState *bs = acb->common.bs;
200161007b31SStefan Hajnoczi 
200261007b31SStefan Hajnoczi         acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
200361007b31SStefan Hajnoczi         qemu_bh_schedule(acb->bh);
200461007b31SStefan Hajnoczi     }
200561007b31SStefan Hajnoczi }
200661007b31SStefan Hajnoczi 
200761007b31SStefan Hajnoczi /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
200861007b31SStefan Hajnoczi static void coroutine_fn bdrv_co_do_rw(void *opaque)
200961007b31SStefan Hajnoczi {
201061007b31SStefan Hajnoczi     BlockAIOCBCoroutine *acb = opaque;
201161007b31SStefan Hajnoczi     BlockDriverState *bs = acb->common.bs;
201261007b31SStefan Hajnoczi 
201361007b31SStefan Hajnoczi     if (!acb->is_write) {
201461007b31SStefan Hajnoczi         acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
201561007b31SStefan Hajnoczi             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
201661007b31SStefan Hajnoczi     } else {
201761007b31SStefan Hajnoczi         acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
201861007b31SStefan Hajnoczi             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
201961007b31SStefan Hajnoczi     }
202061007b31SStefan Hajnoczi 
202161007b31SStefan Hajnoczi     bdrv_co_complete(acb);
202261007b31SStefan Hajnoczi }
202361007b31SStefan Hajnoczi 
202461007b31SStefan Hajnoczi static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
202561007b31SStefan Hajnoczi                                          int64_t sector_num,
202661007b31SStefan Hajnoczi                                          QEMUIOVector *qiov,
202761007b31SStefan Hajnoczi                                          int nb_sectors,
202861007b31SStefan Hajnoczi                                          BdrvRequestFlags flags,
202961007b31SStefan Hajnoczi                                          BlockCompletionFunc *cb,
203061007b31SStefan Hajnoczi                                          void *opaque,
203161007b31SStefan Hajnoczi                                          bool is_write)
203261007b31SStefan Hajnoczi {
203361007b31SStefan Hajnoczi     Coroutine *co;
203461007b31SStefan Hajnoczi     BlockAIOCBCoroutine *acb;
203561007b31SStefan Hajnoczi 
203661007b31SStefan Hajnoczi     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
203761007b31SStefan Hajnoczi     acb->need_bh = true;
203861007b31SStefan Hajnoczi     acb->req.error = -EINPROGRESS;
203961007b31SStefan Hajnoczi     acb->req.sector = sector_num;
204061007b31SStefan Hajnoczi     acb->req.nb_sectors = nb_sectors;
204161007b31SStefan Hajnoczi     acb->req.qiov = qiov;
204261007b31SStefan Hajnoczi     acb->req.flags = flags;
204361007b31SStefan Hajnoczi     acb->is_write = is_write;
204461007b31SStefan Hajnoczi 
204561007b31SStefan Hajnoczi     co = qemu_coroutine_create(bdrv_co_do_rw);
204661007b31SStefan Hajnoczi     qemu_coroutine_enter(co, acb);
204761007b31SStefan Hajnoczi 
204861007b31SStefan Hajnoczi     bdrv_co_maybe_schedule_bh(acb);
204961007b31SStefan Hajnoczi     return &acb->common;
205061007b31SStefan Hajnoczi }
205161007b31SStefan Hajnoczi 
205261007b31SStefan Hajnoczi static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
205361007b31SStefan Hajnoczi {
205461007b31SStefan Hajnoczi     BlockAIOCBCoroutine *acb = opaque;
205561007b31SStefan Hajnoczi     BlockDriverState *bs = acb->common.bs;
205661007b31SStefan Hajnoczi 
205761007b31SStefan Hajnoczi     acb->req.error = bdrv_co_flush(bs);
205861007b31SStefan Hajnoczi     bdrv_co_complete(acb);
205961007b31SStefan Hajnoczi }
206061007b31SStefan Hajnoczi 
206161007b31SStefan Hajnoczi BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
206261007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque)
206361007b31SStefan Hajnoczi {
206461007b31SStefan Hajnoczi     trace_bdrv_aio_flush(bs, opaque);
206561007b31SStefan Hajnoczi 
206661007b31SStefan Hajnoczi     Coroutine *co;
206761007b31SStefan Hajnoczi     BlockAIOCBCoroutine *acb;
206861007b31SStefan Hajnoczi 
206961007b31SStefan Hajnoczi     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
207061007b31SStefan Hajnoczi     acb->need_bh = true;
207161007b31SStefan Hajnoczi     acb->req.error = -EINPROGRESS;
207261007b31SStefan Hajnoczi 
207361007b31SStefan Hajnoczi     co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
207461007b31SStefan Hajnoczi     qemu_coroutine_enter(co, acb);
207561007b31SStefan Hajnoczi 
207661007b31SStefan Hajnoczi     bdrv_co_maybe_schedule_bh(acb);
207761007b31SStefan Hajnoczi     return &acb->common;
207861007b31SStefan Hajnoczi }
207961007b31SStefan Hajnoczi 
208061007b31SStefan Hajnoczi static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
208161007b31SStefan Hajnoczi {
208261007b31SStefan Hajnoczi     BlockAIOCBCoroutine *acb = opaque;
208361007b31SStefan Hajnoczi     BlockDriverState *bs = acb->common.bs;
208461007b31SStefan Hajnoczi 
208561007b31SStefan Hajnoczi     acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
208661007b31SStefan Hajnoczi     bdrv_co_complete(acb);
208761007b31SStefan Hajnoczi }
208861007b31SStefan Hajnoczi 
208961007b31SStefan Hajnoczi BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs,
209061007b31SStefan Hajnoczi         int64_t sector_num, int nb_sectors,
209161007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque)
209261007b31SStefan Hajnoczi {
209361007b31SStefan Hajnoczi     Coroutine *co;
209461007b31SStefan Hajnoczi     BlockAIOCBCoroutine *acb;
209561007b31SStefan Hajnoczi 
209661007b31SStefan Hajnoczi     trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
209761007b31SStefan Hajnoczi 
209861007b31SStefan Hajnoczi     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
209961007b31SStefan Hajnoczi     acb->need_bh = true;
210061007b31SStefan Hajnoczi     acb->req.error = -EINPROGRESS;
210161007b31SStefan Hajnoczi     acb->req.sector = sector_num;
210261007b31SStefan Hajnoczi     acb->req.nb_sectors = nb_sectors;
210361007b31SStefan Hajnoczi     co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
210461007b31SStefan Hajnoczi     qemu_coroutine_enter(co, acb);
210561007b31SStefan Hajnoczi 
210661007b31SStefan Hajnoczi     bdrv_co_maybe_schedule_bh(acb);
210761007b31SStefan Hajnoczi     return &acb->common;
210861007b31SStefan Hajnoczi }
210961007b31SStefan Hajnoczi 
211061007b31SStefan Hajnoczi void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
211161007b31SStefan Hajnoczi                    BlockCompletionFunc *cb, void *opaque)
211261007b31SStefan Hajnoczi {
211361007b31SStefan Hajnoczi     BlockAIOCB *acb;
211461007b31SStefan Hajnoczi 
211561007b31SStefan Hajnoczi     acb = g_slice_alloc(aiocb_info->aiocb_size);
211661007b31SStefan Hajnoczi     acb->aiocb_info = aiocb_info;
211761007b31SStefan Hajnoczi     acb->bs = bs;
211861007b31SStefan Hajnoczi     acb->cb = cb;
211961007b31SStefan Hajnoczi     acb->opaque = opaque;
212061007b31SStefan Hajnoczi     acb->refcnt = 1;
212161007b31SStefan Hajnoczi     return acb;
212261007b31SStefan Hajnoczi }
212361007b31SStefan Hajnoczi 
212461007b31SStefan Hajnoczi void qemu_aio_ref(void *p)
212561007b31SStefan Hajnoczi {
212661007b31SStefan Hajnoczi     BlockAIOCB *acb = p;
212761007b31SStefan Hajnoczi     acb->refcnt++;
212861007b31SStefan Hajnoczi }
212961007b31SStefan Hajnoczi 
213061007b31SStefan Hajnoczi void qemu_aio_unref(void *p)
213161007b31SStefan Hajnoczi {
213261007b31SStefan Hajnoczi     BlockAIOCB *acb = p;
213361007b31SStefan Hajnoczi     assert(acb->refcnt > 0);
213461007b31SStefan Hajnoczi     if (--acb->refcnt == 0) {
213561007b31SStefan Hajnoczi         g_slice_free1(acb->aiocb_info->aiocb_size, acb);
213661007b31SStefan Hajnoczi     }
213761007b31SStefan Hajnoczi }
213861007b31SStefan Hajnoczi 
213961007b31SStefan Hajnoczi /**************************************************************/
214061007b31SStefan Hajnoczi /* Coroutine block device emulation */
214161007b31SStefan Hajnoczi 
214261007b31SStefan Hajnoczi typedef struct CoroutineIOCompletion {
214361007b31SStefan Hajnoczi     Coroutine *coroutine;
214461007b31SStefan Hajnoczi     int ret;
214561007b31SStefan Hajnoczi } CoroutineIOCompletion;
214661007b31SStefan Hajnoczi 
214761007b31SStefan Hajnoczi static void bdrv_co_io_em_complete(void *opaque, int ret)
214861007b31SStefan Hajnoczi {
214961007b31SStefan Hajnoczi     CoroutineIOCompletion *co = opaque;
215061007b31SStefan Hajnoczi 
215161007b31SStefan Hajnoczi     co->ret = ret;
215261007b31SStefan Hajnoczi     qemu_coroutine_enter(co->coroutine, NULL);
215361007b31SStefan Hajnoczi }
215461007b31SStefan Hajnoczi 
215561007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
215661007b31SStefan Hajnoczi                                       int nb_sectors, QEMUIOVector *iov,
215761007b31SStefan Hajnoczi                                       bool is_write)
215861007b31SStefan Hajnoczi {
215961007b31SStefan Hajnoczi     CoroutineIOCompletion co = {
216061007b31SStefan Hajnoczi         .coroutine = qemu_coroutine_self(),
216161007b31SStefan Hajnoczi     };
216261007b31SStefan Hajnoczi     BlockAIOCB *acb;
216361007b31SStefan Hajnoczi 
216461007b31SStefan Hajnoczi     if (is_write) {
216561007b31SStefan Hajnoczi         acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
216661007b31SStefan Hajnoczi                                        bdrv_co_io_em_complete, &co);
216761007b31SStefan Hajnoczi     } else {
216861007b31SStefan Hajnoczi         acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
216961007b31SStefan Hajnoczi                                       bdrv_co_io_em_complete, &co);
217061007b31SStefan Hajnoczi     }
217161007b31SStefan Hajnoczi 
217261007b31SStefan Hajnoczi     trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
217361007b31SStefan Hajnoczi     if (!acb) {
217461007b31SStefan Hajnoczi         return -EIO;
217561007b31SStefan Hajnoczi     }
217661007b31SStefan Hajnoczi     qemu_coroutine_yield();
217761007b31SStefan Hajnoczi 
217861007b31SStefan Hajnoczi     return co.ret;
217961007b31SStefan Hajnoczi }
218061007b31SStefan Hajnoczi 
218161007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
218261007b31SStefan Hajnoczi                                          int64_t sector_num, int nb_sectors,
218361007b31SStefan Hajnoczi                                          QEMUIOVector *iov)
218461007b31SStefan Hajnoczi {
218561007b31SStefan Hajnoczi     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
218661007b31SStefan Hajnoczi }
218761007b31SStefan Hajnoczi 
218861007b31SStefan Hajnoczi static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
218961007b31SStefan Hajnoczi                                          int64_t sector_num, int nb_sectors,
219061007b31SStefan Hajnoczi                                          QEMUIOVector *iov)
219161007b31SStefan Hajnoczi {
219261007b31SStefan Hajnoczi     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
219361007b31SStefan Hajnoczi }
219461007b31SStefan Hajnoczi 
219561007b31SStefan Hajnoczi static void coroutine_fn bdrv_flush_co_entry(void *opaque)
219661007b31SStefan Hajnoczi {
219761007b31SStefan Hajnoczi     RwCo *rwco = opaque;
219861007b31SStefan Hajnoczi 
219961007b31SStefan Hajnoczi     rwco->ret = bdrv_co_flush(rwco->bs);
220061007b31SStefan Hajnoczi }
220161007b31SStefan Hajnoczi 
220261007b31SStefan Hajnoczi int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
220361007b31SStefan Hajnoczi {
220461007b31SStefan Hajnoczi     int ret;
220561007b31SStefan Hajnoczi 
220661007b31SStefan Hajnoczi     if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
220761007b31SStefan Hajnoczi         return 0;
220861007b31SStefan Hajnoczi     }
220961007b31SStefan Hajnoczi 
221061007b31SStefan Hajnoczi     /* Write back cached data to the OS even with cache=unsafe */
221161007b31SStefan Hajnoczi     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
221261007b31SStefan Hajnoczi     if (bs->drv->bdrv_co_flush_to_os) {
221361007b31SStefan Hajnoczi         ret = bs->drv->bdrv_co_flush_to_os(bs);
221461007b31SStefan Hajnoczi         if (ret < 0) {
221561007b31SStefan Hajnoczi             return ret;
221661007b31SStefan Hajnoczi         }
221761007b31SStefan Hajnoczi     }
221861007b31SStefan Hajnoczi 
221961007b31SStefan Hajnoczi     /* But don't actually force it to the disk with cache=unsafe */
222061007b31SStefan Hajnoczi     if (bs->open_flags & BDRV_O_NO_FLUSH) {
222161007b31SStefan Hajnoczi         goto flush_parent;
222261007b31SStefan Hajnoczi     }
222361007b31SStefan Hajnoczi 
222461007b31SStefan Hajnoczi     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
222561007b31SStefan Hajnoczi     if (bs->drv->bdrv_co_flush_to_disk) {
222661007b31SStefan Hajnoczi         ret = bs->drv->bdrv_co_flush_to_disk(bs);
222761007b31SStefan Hajnoczi     } else if (bs->drv->bdrv_aio_flush) {
222861007b31SStefan Hajnoczi         BlockAIOCB *acb;
222961007b31SStefan Hajnoczi         CoroutineIOCompletion co = {
223061007b31SStefan Hajnoczi             .coroutine = qemu_coroutine_self(),
223161007b31SStefan Hajnoczi         };
223261007b31SStefan Hajnoczi 
223361007b31SStefan Hajnoczi         acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
223461007b31SStefan Hajnoczi         if (acb == NULL) {
223561007b31SStefan Hajnoczi             ret = -EIO;
223661007b31SStefan Hajnoczi         } else {
223761007b31SStefan Hajnoczi             qemu_coroutine_yield();
223861007b31SStefan Hajnoczi             ret = co.ret;
223961007b31SStefan Hajnoczi         }
224061007b31SStefan Hajnoczi     } else {
224161007b31SStefan Hajnoczi         /*
224261007b31SStefan Hajnoczi          * Some block drivers always operate in either writethrough or unsafe
224361007b31SStefan Hajnoczi          * mode and don't support bdrv_flush therefore. Usually qemu doesn't
224461007b31SStefan Hajnoczi          * know how the server works (because the behaviour is hardcoded or
224561007b31SStefan Hajnoczi          * depends on server-side configuration), so we can't ensure that
224661007b31SStefan Hajnoczi          * everything is safe on disk. Returning an error doesn't work because
224761007b31SStefan Hajnoczi          * that would break guests even if the server operates in writethrough
224861007b31SStefan Hajnoczi          * mode.
224961007b31SStefan Hajnoczi          *
225061007b31SStefan Hajnoczi          * Let's hope the user knows what he's doing.
225161007b31SStefan Hajnoczi          */
225261007b31SStefan Hajnoczi         ret = 0;
225361007b31SStefan Hajnoczi     }
225461007b31SStefan Hajnoczi     if (ret < 0) {
225561007b31SStefan Hajnoczi         return ret;
225661007b31SStefan Hajnoczi     }
225761007b31SStefan Hajnoczi 
225861007b31SStefan Hajnoczi     /* Now flush the underlying protocol.  It will also have BDRV_O_NO_FLUSH
225961007b31SStefan Hajnoczi      * in the case of cache=unsafe, so there are no useless flushes.
226061007b31SStefan Hajnoczi      */
226161007b31SStefan Hajnoczi flush_parent:
226261007b31SStefan Hajnoczi     return bdrv_co_flush(bs->file);
226361007b31SStefan Hajnoczi }
226461007b31SStefan Hajnoczi 
226561007b31SStefan Hajnoczi int bdrv_flush(BlockDriverState *bs)
226661007b31SStefan Hajnoczi {
226761007b31SStefan Hajnoczi     Coroutine *co;
226861007b31SStefan Hajnoczi     RwCo rwco = {
226961007b31SStefan Hajnoczi         .bs = bs,
227061007b31SStefan Hajnoczi         .ret = NOT_DONE,
227161007b31SStefan Hajnoczi     };
227261007b31SStefan Hajnoczi 
227361007b31SStefan Hajnoczi     if (qemu_in_coroutine()) {
227461007b31SStefan Hajnoczi         /* Fast-path if already in coroutine context */
227561007b31SStefan Hajnoczi         bdrv_flush_co_entry(&rwco);
227661007b31SStefan Hajnoczi     } else {
227761007b31SStefan Hajnoczi         AioContext *aio_context = bdrv_get_aio_context(bs);
227861007b31SStefan Hajnoczi 
227961007b31SStefan Hajnoczi         co = qemu_coroutine_create(bdrv_flush_co_entry);
228061007b31SStefan Hajnoczi         qemu_coroutine_enter(co, &rwco);
228161007b31SStefan Hajnoczi         while (rwco.ret == NOT_DONE) {
228261007b31SStefan Hajnoczi             aio_poll(aio_context, true);
228361007b31SStefan Hajnoczi         }
228461007b31SStefan Hajnoczi     }
228561007b31SStefan Hajnoczi 
228661007b31SStefan Hajnoczi     return rwco.ret;
228761007b31SStefan Hajnoczi }
228861007b31SStefan Hajnoczi 
228961007b31SStefan Hajnoczi typedef struct DiscardCo {
229061007b31SStefan Hajnoczi     BlockDriverState *bs;
229161007b31SStefan Hajnoczi     int64_t sector_num;
229261007b31SStefan Hajnoczi     int nb_sectors;
229361007b31SStefan Hajnoczi     int ret;
229461007b31SStefan Hajnoczi } DiscardCo;
229561007b31SStefan Hajnoczi static void coroutine_fn bdrv_discard_co_entry(void *opaque)
229661007b31SStefan Hajnoczi {
229761007b31SStefan Hajnoczi     DiscardCo *rwco = opaque;
229861007b31SStefan Hajnoczi 
229961007b31SStefan Hajnoczi     rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
230061007b31SStefan Hajnoczi }
230161007b31SStefan Hajnoczi 
230261007b31SStefan Hajnoczi int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
230361007b31SStefan Hajnoczi                                  int nb_sectors)
230461007b31SStefan Hajnoczi {
230561007b31SStefan Hajnoczi     int max_discard, ret;
230661007b31SStefan Hajnoczi 
230761007b31SStefan Hajnoczi     if (!bs->drv) {
230861007b31SStefan Hajnoczi         return -ENOMEDIUM;
230961007b31SStefan Hajnoczi     }
231061007b31SStefan Hajnoczi 
231161007b31SStefan Hajnoczi     ret = bdrv_check_request(bs, sector_num, nb_sectors);
231261007b31SStefan Hajnoczi     if (ret < 0) {
231361007b31SStefan Hajnoczi         return ret;
231461007b31SStefan Hajnoczi     } else if (bs->read_only) {
2315eaf5fe2dSPaolo Bonzini         return -EPERM;
231661007b31SStefan Hajnoczi     }
231761007b31SStefan Hajnoczi 
231861007b31SStefan Hajnoczi     bdrv_reset_dirty(bs, sector_num, nb_sectors);
231961007b31SStefan Hajnoczi 
232061007b31SStefan Hajnoczi     /* Do nothing if disabled.  */
232161007b31SStefan Hajnoczi     if (!(bs->open_flags & BDRV_O_UNMAP)) {
232261007b31SStefan Hajnoczi         return 0;
232361007b31SStefan Hajnoczi     }
232461007b31SStefan Hajnoczi 
232561007b31SStefan Hajnoczi     if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
232661007b31SStefan Hajnoczi         return 0;
232761007b31SStefan Hajnoczi     }
232861007b31SStefan Hajnoczi 
232961007b31SStefan Hajnoczi     max_discard = MIN_NON_ZERO(bs->bl.max_discard, BDRV_REQUEST_MAX_SECTORS);
233061007b31SStefan Hajnoczi     while (nb_sectors > 0) {
233161007b31SStefan Hajnoczi         int ret;
233261007b31SStefan Hajnoczi         int num = nb_sectors;
233361007b31SStefan Hajnoczi 
233461007b31SStefan Hajnoczi         /* align request */
233561007b31SStefan Hajnoczi         if (bs->bl.discard_alignment &&
233661007b31SStefan Hajnoczi             num >= bs->bl.discard_alignment &&
233761007b31SStefan Hajnoczi             sector_num % bs->bl.discard_alignment) {
233861007b31SStefan Hajnoczi             if (num > bs->bl.discard_alignment) {
233961007b31SStefan Hajnoczi                 num = bs->bl.discard_alignment;
234061007b31SStefan Hajnoczi             }
234161007b31SStefan Hajnoczi             num -= sector_num % bs->bl.discard_alignment;
234261007b31SStefan Hajnoczi         }
234361007b31SStefan Hajnoczi 
234461007b31SStefan Hajnoczi         /* limit request size */
234561007b31SStefan Hajnoczi         if (num > max_discard) {
234661007b31SStefan Hajnoczi             num = max_discard;
234761007b31SStefan Hajnoczi         }
234861007b31SStefan Hajnoczi 
234961007b31SStefan Hajnoczi         if (bs->drv->bdrv_co_discard) {
235061007b31SStefan Hajnoczi             ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
235161007b31SStefan Hajnoczi         } else {
235261007b31SStefan Hajnoczi             BlockAIOCB *acb;
235361007b31SStefan Hajnoczi             CoroutineIOCompletion co = {
235461007b31SStefan Hajnoczi                 .coroutine = qemu_coroutine_self(),
235561007b31SStefan Hajnoczi             };
235661007b31SStefan Hajnoczi 
235761007b31SStefan Hajnoczi             acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
235861007b31SStefan Hajnoczi                                             bdrv_co_io_em_complete, &co);
235961007b31SStefan Hajnoczi             if (acb == NULL) {
236061007b31SStefan Hajnoczi                 return -EIO;
236161007b31SStefan Hajnoczi             } else {
236261007b31SStefan Hajnoczi                 qemu_coroutine_yield();
236361007b31SStefan Hajnoczi                 ret = co.ret;
236461007b31SStefan Hajnoczi             }
236561007b31SStefan Hajnoczi         }
236661007b31SStefan Hajnoczi         if (ret && ret != -ENOTSUP) {
236761007b31SStefan Hajnoczi             return ret;
236861007b31SStefan Hajnoczi         }
236961007b31SStefan Hajnoczi 
237061007b31SStefan Hajnoczi         sector_num += num;
237161007b31SStefan Hajnoczi         nb_sectors -= num;
237261007b31SStefan Hajnoczi     }
237361007b31SStefan Hajnoczi     return 0;
237461007b31SStefan Hajnoczi }
237561007b31SStefan Hajnoczi 
237661007b31SStefan Hajnoczi int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
237761007b31SStefan Hajnoczi {
237861007b31SStefan Hajnoczi     Coroutine *co;
237961007b31SStefan Hajnoczi     DiscardCo rwco = {
238061007b31SStefan Hajnoczi         .bs = bs,
238161007b31SStefan Hajnoczi         .sector_num = sector_num,
238261007b31SStefan Hajnoczi         .nb_sectors = nb_sectors,
238361007b31SStefan Hajnoczi         .ret = NOT_DONE,
238461007b31SStefan Hajnoczi     };
238561007b31SStefan Hajnoczi 
238661007b31SStefan Hajnoczi     if (qemu_in_coroutine()) {
238761007b31SStefan Hajnoczi         /* Fast-path if already in coroutine context */
238861007b31SStefan Hajnoczi         bdrv_discard_co_entry(&rwco);
238961007b31SStefan Hajnoczi     } else {
239061007b31SStefan Hajnoczi         AioContext *aio_context = bdrv_get_aio_context(bs);
239161007b31SStefan Hajnoczi 
239261007b31SStefan Hajnoczi         co = qemu_coroutine_create(bdrv_discard_co_entry);
239361007b31SStefan Hajnoczi         qemu_coroutine_enter(co, &rwco);
239461007b31SStefan Hajnoczi         while (rwco.ret == NOT_DONE) {
239561007b31SStefan Hajnoczi             aio_poll(aio_context, true);
239661007b31SStefan Hajnoczi         }
239761007b31SStefan Hajnoczi     }
239861007b31SStefan Hajnoczi 
239961007b31SStefan Hajnoczi     return rwco.ret;
240061007b31SStefan Hajnoczi }
240161007b31SStefan Hajnoczi 
240261007b31SStefan Hajnoczi /* needed for generic scsi interface */
240361007b31SStefan Hajnoczi 
240461007b31SStefan Hajnoczi int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
240561007b31SStefan Hajnoczi {
240661007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
240761007b31SStefan Hajnoczi 
240861007b31SStefan Hajnoczi     if (drv && drv->bdrv_ioctl)
240961007b31SStefan Hajnoczi         return drv->bdrv_ioctl(bs, req, buf);
241061007b31SStefan Hajnoczi     return -ENOTSUP;
241161007b31SStefan Hajnoczi }
241261007b31SStefan Hajnoczi 
241361007b31SStefan Hajnoczi BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
241461007b31SStefan Hajnoczi         unsigned long int req, void *buf,
241561007b31SStefan Hajnoczi         BlockCompletionFunc *cb, void *opaque)
241661007b31SStefan Hajnoczi {
241761007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
241861007b31SStefan Hajnoczi 
241961007b31SStefan Hajnoczi     if (drv && drv->bdrv_aio_ioctl)
242061007b31SStefan Hajnoczi         return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
242161007b31SStefan Hajnoczi     return NULL;
242261007b31SStefan Hajnoczi }
242361007b31SStefan Hajnoczi 
242461007b31SStefan Hajnoczi void *qemu_blockalign(BlockDriverState *bs, size_t size)
242561007b31SStefan Hajnoczi {
242661007b31SStefan Hajnoczi     return qemu_memalign(bdrv_opt_mem_align(bs), size);
242761007b31SStefan Hajnoczi }
242861007b31SStefan Hajnoczi 
242961007b31SStefan Hajnoczi void *qemu_blockalign0(BlockDriverState *bs, size_t size)
243061007b31SStefan Hajnoczi {
243161007b31SStefan Hajnoczi     return memset(qemu_blockalign(bs, size), 0, size);
243261007b31SStefan Hajnoczi }
243361007b31SStefan Hajnoczi 
243461007b31SStefan Hajnoczi void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
243561007b31SStefan Hajnoczi {
243661007b31SStefan Hajnoczi     size_t align = bdrv_opt_mem_align(bs);
243761007b31SStefan Hajnoczi 
243861007b31SStefan Hajnoczi     /* Ensure that NULL is never returned on success */
243961007b31SStefan Hajnoczi     assert(align > 0);
244061007b31SStefan Hajnoczi     if (size == 0) {
244161007b31SStefan Hajnoczi         size = align;
244261007b31SStefan Hajnoczi     }
244361007b31SStefan Hajnoczi 
244461007b31SStefan Hajnoczi     return qemu_try_memalign(align, size);
244561007b31SStefan Hajnoczi }
244661007b31SStefan Hajnoczi 
244761007b31SStefan Hajnoczi void *qemu_try_blockalign0(BlockDriverState *bs, size_t size)
244861007b31SStefan Hajnoczi {
244961007b31SStefan Hajnoczi     void *mem = qemu_try_blockalign(bs, size);
245061007b31SStefan Hajnoczi 
245161007b31SStefan Hajnoczi     if (mem) {
245261007b31SStefan Hajnoczi         memset(mem, 0, size);
245361007b31SStefan Hajnoczi     }
245461007b31SStefan Hajnoczi 
245561007b31SStefan Hajnoczi     return mem;
245661007b31SStefan Hajnoczi }
245761007b31SStefan Hajnoczi 
245861007b31SStefan Hajnoczi /*
245961007b31SStefan Hajnoczi  * Check if all memory in this vector is sector aligned.
246061007b31SStefan Hajnoczi  */
246161007b31SStefan Hajnoczi bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
246261007b31SStefan Hajnoczi {
246361007b31SStefan Hajnoczi     int i;
24644196d2f0SDenis V. Lunev     size_t alignment = bdrv_min_mem_align(bs);
246561007b31SStefan Hajnoczi 
246661007b31SStefan Hajnoczi     for (i = 0; i < qiov->niov; i++) {
246761007b31SStefan Hajnoczi         if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
246861007b31SStefan Hajnoczi             return false;
246961007b31SStefan Hajnoczi         }
247061007b31SStefan Hajnoczi         if (qiov->iov[i].iov_len % alignment) {
247161007b31SStefan Hajnoczi             return false;
247261007b31SStefan Hajnoczi         }
247361007b31SStefan Hajnoczi     }
247461007b31SStefan Hajnoczi 
247561007b31SStefan Hajnoczi     return true;
247661007b31SStefan Hajnoczi }
247761007b31SStefan Hajnoczi 
247861007b31SStefan Hajnoczi void bdrv_add_before_write_notifier(BlockDriverState *bs,
247961007b31SStefan Hajnoczi                                     NotifierWithReturn *notifier)
248061007b31SStefan Hajnoczi {
248161007b31SStefan Hajnoczi     notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
248261007b31SStefan Hajnoczi }
248361007b31SStefan Hajnoczi 
248461007b31SStefan Hajnoczi void bdrv_io_plug(BlockDriverState *bs)
248561007b31SStefan Hajnoczi {
248661007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
248761007b31SStefan Hajnoczi     if (drv && drv->bdrv_io_plug) {
248861007b31SStefan Hajnoczi         drv->bdrv_io_plug(bs);
248961007b31SStefan Hajnoczi     } else if (bs->file) {
249061007b31SStefan Hajnoczi         bdrv_io_plug(bs->file);
249161007b31SStefan Hajnoczi     }
249261007b31SStefan Hajnoczi }
249361007b31SStefan Hajnoczi 
249461007b31SStefan Hajnoczi void bdrv_io_unplug(BlockDriverState *bs)
249561007b31SStefan Hajnoczi {
249661007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
249761007b31SStefan Hajnoczi     if (drv && drv->bdrv_io_unplug) {
249861007b31SStefan Hajnoczi         drv->bdrv_io_unplug(bs);
249961007b31SStefan Hajnoczi     } else if (bs->file) {
250061007b31SStefan Hajnoczi         bdrv_io_unplug(bs->file);
250161007b31SStefan Hajnoczi     }
250261007b31SStefan Hajnoczi }
250361007b31SStefan Hajnoczi 
250461007b31SStefan Hajnoczi void bdrv_flush_io_queue(BlockDriverState *bs)
250561007b31SStefan Hajnoczi {
250661007b31SStefan Hajnoczi     BlockDriver *drv = bs->drv;
250761007b31SStefan Hajnoczi     if (drv && drv->bdrv_flush_io_queue) {
250861007b31SStefan Hajnoczi         drv->bdrv_flush_io_queue(bs);
250961007b31SStefan Hajnoczi     } else if (bs->file) {
251061007b31SStefan Hajnoczi         bdrv_flush_io_queue(bs->file);
251161007b31SStefan Hajnoczi     }
251261007b31SStefan Hajnoczi }
2513