2015-04-28 16:27:52 +03:00
|
|
|
/*
|
|
|
|
* Block layer I/O functions
|
|
|
|
*
|
|
|
|
* Copyright (c) 2003 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-01-18 21:01:42 +03:00
|
|
|
#include "qemu/osdep.h"
|
2015-04-28 16:27:52 +03:00
|
|
|
#include "trace.h"
|
2015-10-19 18:53:21 +03:00
|
|
|
#include "sysemu/block-backend.h"
|
2015-04-28 16:27:52 +03:00
|
|
|
#include "block/blockjob.h"
|
2017-05-08 17:13:03 +03:00
|
|
|
#include "block/blockjob_int.h"
|
2015-04-28 16:27:52 +03:00
|
|
|
#include "block/block_int.h"
|
2016-03-20 20:16:19 +03:00
|
|
|
#include "qemu/cutils.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 11:01:28 +03:00
|
|
|
#include "qapi/error.h"
|
2015-03-17 20:29:20 +03:00
|
|
|
#include "qemu/error-report.h"
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
|
|
|
|
|
2016-06-02 00:10:03 +03:00
|
|
|
static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
|
2017-06-09 13:18:08 +03:00
|
|
|
int64_t offset, int bytes, BdrvRequestFlags flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-04-08 06:34:45 +03:00
|
|
|
void bdrv_parent_drained_begin(BlockDriverState *bs)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2016-03-22 14:05:35 +03:00
|
|
|
BdrvChild *c;
|
2016-03-21 14:56:44 +03:00
|
|
|
|
2016-03-22 14:05:35 +03:00
|
|
|
QLIST_FOREACH(c, &bs->parents, next_parent) {
|
|
|
|
if (c->role->drained_begin) {
|
|
|
|
c->role->drained_begin(c);
|
|
|
|
}
|
2016-04-07 19:33:33 +03:00
|
|
|
}
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-04-08 06:34:45 +03:00
|
|
|
void bdrv_parent_drained_end(BlockDriverState *bs)
|
2016-04-07 19:33:33 +03:00
|
|
|
{
|
2016-03-22 14:05:35 +03:00
|
|
|
BdrvChild *c;
|
2016-03-21 14:56:44 +03:00
|
|
|
|
2016-03-22 14:05:35 +03:00
|
|
|
QLIST_FOREACH(c, &bs->parents, next_parent) {
|
|
|
|
if (c->role->drained_end) {
|
|
|
|
c->role->drained_end(c);
|
|
|
|
}
|
2016-03-21 14:56:44 +03:00
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-06-24 01:37:23 +03:00
|
|
|
static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src)
|
|
|
|
{
|
|
|
|
dst->opt_transfer = MAX(dst->opt_transfer, src->opt_transfer);
|
|
|
|
dst->max_transfer = MIN_NON_ZERO(dst->max_transfer, src->max_transfer);
|
|
|
|
dst->opt_mem_alignment = MAX(dst->opt_mem_alignment,
|
|
|
|
src->opt_mem_alignment);
|
|
|
|
dst->min_mem_alignment = MAX(dst->min_mem_alignment,
|
|
|
|
src->min_mem_alignment);
|
|
|
|
dst->max_iov = MIN_NON_ZERO(dst->max_iov, src->max_iov);
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
memset(&bs->bl, 0, sizeof(bs->bl));
|
|
|
|
|
|
|
|
if (!drv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-24 01:37:18 +03:00
|
|
|
/* Default alignment based on whether driver has byte interface */
|
2016-06-24 01:37:24 +03:00
|
|
|
bs->bl.request_alignment = drv->bdrv_co_preadv ? 1 : 512;
|
2016-06-24 01:37:18 +03:00
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
/* Take some limits from the children as a default */
|
|
|
|
if (bs->file) {
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_refresh_limits(bs->file->bs, &local_err);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2016-06-24 01:37:23 +03:00
|
|
|
bdrv_merge_limits(&bs->bl, &bs->file->bs->bl);
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
2015-05-12 17:30:55 +03:00
|
|
|
bs->bl.min_mem_alignment = 512;
|
block: align bounce buffers to page
The following sequence
int fd = open(argv[1], O_RDWR | O_CREAT | O_DIRECT, 0644);
for (i = 0; i < 100000; i++)
write(fd, buf, 4096);
performs 5% better if buf is aligned to 4096 bytes.
The difference is quite reliable.
On the other hand we do not want at the moment to enforce bounce
buffering if guest request is aligned to 512 bytes.
The patch changes default bounce buffer optimal alignment to
MAX(page size, 4k). 4k is chosen as maximal known sector size on real
HDD.
The justification of the performance improve is quite interesting.
From the kernel point of view each request to the disk was split
by two. This could be seen by blktrace like this:
9,0 11 1 0.000000000 11151 Q WS 312737792 + 1023 [qemu-img]
9,0 11 2 0.000007938 11151 Q WS 312738815 + 8 [qemu-img]
9,0 11 3 0.000030735 11151 Q WS 312738823 + 1016 [qemu-img]
9,0 11 4 0.000032482 11151 Q WS 312739839 + 8 [qemu-img]
9,0 11 5 0.000041379 11151 Q WS 312739847 + 1016 [qemu-img]
9,0 11 6 0.000042818 11151 Q WS 312740863 + 8 [qemu-img]
9,0 11 7 0.000051236 11151 Q WS 312740871 + 1017 [qemu-img]
9,0 5 1 0.169071519 11151 Q WS 312741888 + 1023 [qemu-img]
After the patch the pattern becomes normal:
9,0 6 1 0.000000000 12422 Q WS 314834944 + 1024 [qemu-img]
9,0 6 2 0.000038527 12422 Q WS 314835968 + 1024 [qemu-img]
9,0 6 3 0.000072849 12422 Q WS 314836992 + 1024 [qemu-img]
9,0 6 4 0.000106276 12422 Q WS 314838016 + 1024 [qemu-img]
and the amount of requests sent to disk (could be calculated counting
number of lines in the output of blktrace) is reduced about 2 times.
Both qemu-img and qemu-io are affected while qemu-kvm is not. The guest
does his job well and real requests comes properly aligned (to page).
Signed-off-by: Denis V. Lunev <den@openvz.org>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 1431441056-26198-3-git-send-email-den@openvz.org
CC: Paolo Bonzini <pbonzini@redhat.com>
CC: Kevin Wolf <kwolf@redhat.com>
CC: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-05-12 17:30:56 +03:00
|
|
|
bs->bl.opt_mem_alignment = getpagesize();
|
2015-07-09 12:56:44 +03:00
|
|
|
|
|
|
|
/* Safe default since most protocols use readv()/writev()/etc */
|
|
|
|
bs->bl.max_iov = IOV_MAX;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2015-06-17 15:55:21 +03:00
|
|
|
if (bs->backing) {
|
|
|
|
bdrv_refresh_limits(bs->backing->bs, &local_err);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2016-06-24 01:37:23 +03:00
|
|
|
bdrv_merge_limits(&bs->bl, &bs->backing->bs->bl);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Then let the driver override it */
|
|
|
|
if (drv->bdrv_refresh_limits) {
|
|
|
|
drv->bdrv_refresh_limits(bs, errp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The copy-on-read flag is actually a reference count so multiple users may
|
|
|
|
* use the feature without worrying about clobbering its previous state.
|
|
|
|
* Copy-on-read stays enabled until all users have called to disable it.
|
|
|
|
*/
|
|
|
|
void bdrv_enable_copy_on_read(BlockDriverState *bs)
|
|
|
|
{
|
2017-06-05 15:38:50 +03:00
|
|
|
atomic_inc(&bs->copy_on_read);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_disable_copy_on_read(BlockDriverState *bs)
|
|
|
|
{
|
2017-06-05 15:38:50 +03:00
|
|
|
int old = atomic_fetch_dec(&bs->copy_on_read);
|
|
|
|
assert(old >= 1);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if any requests are in-flight (including throttled requests) */
|
2015-09-16 17:08:17 +03:00
|
|
|
bool bdrv_requests_pending(BlockDriverState *bs)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2015-10-28 13:46:51 +03:00
|
|
|
BdrvChild *child;
|
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
if (atomic_read(&bs->in_flight)) {
|
2015-04-28 16:27:52 +03:00
|
|
|
return true;
|
|
|
|
}
|
2015-10-28 13:46:51 +03:00
|
|
|
|
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
if (bdrv_requests_pending(child->bs)) {
|
|
|
|
return true;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
2015-10-28 13:46:51 +03:00
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-06-29 16:27:45 +03:00
|
|
|
typedef struct {
|
|
|
|
Coroutine *co;
|
|
|
|
BlockDriverState *bs;
|
|
|
|
bool done;
|
|
|
|
} BdrvCoDrainData;
|
|
|
|
|
|
|
|
static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
|
|
|
|
{
|
|
|
|
BdrvCoDrainData *data = opaque;
|
|
|
|
BlockDriverState *bs = data->bs;
|
|
|
|
|
|
|
|
bs->drv->bdrv_co_drain(bs);
|
|
|
|
|
|
|
|
/* Set data->done before reading bs->wakeup. */
|
|
|
|
atomic_mb_set(&data->done, true);
|
|
|
|
bdrv_wakeup(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bdrv_drain_invoke(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BdrvCoDrainData data = { .bs = bs, .done = false };
|
|
|
|
|
|
|
|
if (!bs->drv || !bs->drv->bdrv_co_drain) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data.co = qemu_coroutine_create(bdrv_drain_invoke_entry, &data);
|
|
|
|
bdrv_coroutine_enter(bs, data.co);
|
|
|
|
BDRV_POLL_WHILE(bs, !data.done);
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:53 +03:00
|
|
|
static bool bdrv_drain_recurse(BlockDriverState *bs)
|
2015-11-09 13:16:53 +03:00
|
|
|
{
|
2017-04-18 17:30:43 +03:00
|
|
|
BdrvChild *child, *tmp;
|
2016-10-27 13:48:53 +03:00
|
|
|
bool waited;
|
|
|
|
|
2016-10-27 13:48:55 +03:00
|
|
|
waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0);
|
2015-11-09 13:16:53 +03:00
|
|
|
|
2017-06-29 16:27:45 +03:00
|
|
|
/* Ensure any pending metadata writes are submitted to bs->file. */
|
|
|
|
bdrv_drain_invoke(bs);
|
2016-10-27 13:48:53 +03:00
|
|
|
|
2017-04-18 17:30:43 +03:00
|
|
|
QLIST_FOREACH_SAFE(child, &bs->children, next, tmp) {
|
|
|
|
BlockDriverState *bs = child->bs;
|
|
|
|
bool in_main_loop =
|
|
|
|
qemu_get_current_aio_context() == qemu_get_aio_context();
|
|
|
|
assert(bs->refcnt > 0);
|
|
|
|
if (in_main_loop) {
|
|
|
|
/* In case the recursive bdrv_drain_recurse processes a
|
|
|
|
* block_job_defer_to_main_loop BH and modifies the graph,
|
|
|
|
* let's hold a reference to bs until we are done.
|
|
|
|
*
|
|
|
|
* IOThread doesn't have such a BH, and it is not safe to call
|
|
|
|
* bdrv_unref without BQL, so skip doing it there.
|
|
|
|
*/
|
|
|
|
bdrv_ref(bs);
|
|
|
|
}
|
|
|
|
waited |= bdrv_drain_recurse(bs);
|
|
|
|
if (in_main_loop) {
|
|
|
|
bdrv_unref(bs);
|
|
|
|
}
|
2015-11-09 13:16:53 +03:00
|
|
|
}
|
2016-10-27 13:48:53 +03:00
|
|
|
|
|
|
|
return waited;
|
2015-11-09 13:16:53 +03:00
|
|
|
}
|
|
|
|
|
2016-04-05 14:20:52 +03:00
|
|
|
static void bdrv_co_drain_bh_cb(void *opaque)
|
|
|
|
{
|
|
|
|
BdrvCoDrainData *data = opaque;
|
|
|
|
Coroutine *co = data->co;
|
2016-10-27 13:48:52 +03:00
|
|
|
BlockDriverState *bs = data->bs;
|
2016-04-05 14:20:52 +03:00
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_dec_in_flight(bs);
|
2016-10-27 13:48:53 +03:00
|
|
|
bdrv_drained_begin(bs);
|
2016-04-05 14:20:52 +03:00
|
|
|
data->done = true;
|
2017-02-13 16:52:31 +03:00
|
|
|
aio_co_wake(co);
|
2016-04-05 14:20:52 +03:00
|
|
|
}
|
|
|
|
|
2016-04-07 19:33:32 +03:00
|
|
|
static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs)
|
2016-04-05 14:20:52 +03:00
|
|
|
{
|
|
|
|
BdrvCoDrainData data;
|
|
|
|
|
|
|
|
/* Calling bdrv_drain() from a BH ensures the current coroutine yields and
|
|
|
|
* other coroutines run if they were queued from
|
|
|
|
* qemu_co_queue_run_restart(). */
|
|
|
|
|
|
|
|
assert(qemu_in_coroutine());
|
|
|
|
data = (BdrvCoDrainData) {
|
|
|
|
.co = qemu_coroutine_self(),
|
|
|
|
.bs = bs,
|
|
|
|
.done = false,
|
|
|
|
};
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_inc_in_flight(bs);
|
2016-10-03 19:14:16 +03:00
|
|
|
aio_bh_schedule_oneshot(bdrv_get_aio_context(bs),
|
|
|
|
bdrv_co_drain_bh_cb, &data);
|
2016-04-05 14:20:52 +03:00
|
|
|
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
/* If we are resumed from some other event (such as an aio completion or a
|
|
|
|
* timer callback), it is a bug in the caller that should be fixed. */
|
|
|
|
assert(data.done);
|
|
|
|
}
|
|
|
|
|
2016-05-23 17:08:55 +03:00
|
|
|
void bdrv_drained_begin(BlockDriverState *bs)
|
|
|
|
{
|
2016-10-27 13:48:53 +03:00
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
bdrv_co_yield_to_drain(bs);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-05 15:38:51 +03:00
|
|
|
if (atomic_fetch_inc(&bs->quiesce_counter) == 0) {
|
2016-05-23 17:08:55 +03:00
|
|
|
aio_disable_external(bdrv_get_aio_context(bs));
|
|
|
|
bdrv_parent_drained_begin(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
bdrv_drain_recurse(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_drained_end(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
assert(bs->quiesce_counter > 0);
|
2017-06-05 15:38:51 +03:00
|
|
|
if (atomic_fetch_dec(&bs->quiesce_counter) > 1) {
|
2016-05-23 17:08:55 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bdrv_parent_drained_end(bs);
|
|
|
|
aio_enable_external(bdrv_get_aio_context(bs));
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
/*
|
2015-11-09 13:16:53 +03:00
|
|
|
* Wait for pending requests to complete on a single BlockDriverState subtree,
|
|
|
|
* and suspend block driver's internal I/O until next request arrives.
|
2015-04-28 16:27:52 +03:00
|
|
|
*
|
|
|
|
* Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState
|
|
|
|
* AioContext.
|
2015-07-02 19:24:41 +03:00
|
|
|
*
|
|
|
|
* Only this BlockDriverState's AioContext is run, so in-flight requests must
|
|
|
|
* not depend on events in other AioContexts. In that case, use
|
|
|
|
* bdrv_drain_all() instead.
|
2015-04-28 16:27:52 +03:00
|
|
|
*/
|
2016-04-07 19:33:32 +03:00
|
|
|
void coroutine_fn bdrv_co_drain(BlockDriverState *bs)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2016-05-23 17:08:55 +03:00
|
|
|
assert(qemu_in_coroutine());
|
|
|
|
bdrv_drained_begin(bs);
|
|
|
|
bdrv_drained_end(bs);
|
2016-04-07 19:33:32 +03:00
|
|
|
}
|
2015-06-10 14:38:17 +03:00
|
|
|
|
2016-04-07 19:33:32 +03:00
|
|
|
void bdrv_drain(BlockDriverState *bs)
|
|
|
|
{
|
2016-05-23 17:08:55 +03:00
|
|
|
bdrv_drained_begin(bs);
|
|
|
|
bdrv_drained_end(bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for pending requests to complete across all BlockDriverStates
|
|
|
|
*
|
|
|
|
* This function does not flush data to disk, use bdrv_flush_all() for that
|
|
|
|
* after calling this function.
|
2016-10-28 10:08:02 +03:00
|
|
|
*
|
|
|
|
* This pauses all block jobs and disables external clients. It must
|
|
|
|
* be paired with bdrv_drain_all_end().
|
|
|
|
*
|
|
|
|
* NOTE: no new block jobs or BlockDriverStates can be created between
|
|
|
|
* the bdrv_drain_all_begin() and bdrv_drain_all_end() calls.
|
2015-04-28 16:27:52 +03:00
|
|
|
*/
|
2016-10-28 10:08:02 +03:00
|
|
|
void bdrv_drain_all_begin(void)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
/* Always run first iteration so any pending completion BHs run */
|
2016-10-27 13:48:52 +03:00
|
|
|
bool waited = true;
|
2016-03-22 20:58:50 +03:00
|
|
|
BlockDriverState *bs;
|
2016-05-20 19:49:07 +03:00
|
|
|
BdrvNextIterator it;
|
2015-06-10 14:38:17 +03:00
|
|
|
GSList *aio_ctxs = NULL, *ctx;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-05-08 17:13:03 +03:00
|
|
|
block_job_pause_all();
|
2016-05-27 13:53:36 +03:00
|
|
|
|
2016-05-20 19:49:07 +03:00
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
2015-04-28 16:27:52 +03:00
|
|
|
AioContext *aio_context = bdrv_get_aio_context(bs);
|
|
|
|
|
|
|
|
aio_context_acquire(aio_context);
|
2016-03-22 14:05:35 +03:00
|
|
|
bdrv_parent_drained_begin(bs);
|
2016-10-28 10:08:02 +03:00
|
|
|
aio_disable_external(aio_context);
|
2015-04-28 16:27:52 +03:00
|
|
|
aio_context_release(aio_context);
|
2015-06-10 14:38:17 +03:00
|
|
|
|
2015-06-29 16:12:13 +03:00
|
|
|
if (!g_slist_find(aio_ctxs, aio_context)) {
|
2015-06-10 14:38:17 +03:00
|
|
|
aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2015-07-02 19:24:41 +03:00
|
|
|
/* Note that completion of an asynchronous I/O operation can trigger any
|
|
|
|
* number of other I/O operations on other devices---for example a
|
|
|
|
* coroutine can submit an I/O request to another device in response to
|
|
|
|
* request completion. Therefore we must keep looping until there was no
|
|
|
|
* more activity rather than simply draining each device independently.
|
|
|
|
*/
|
2016-10-27 13:48:52 +03:00
|
|
|
while (waited) {
|
|
|
|
waited = false;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2015-06-10 14:38:17 +03:00
|
|
|
for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
|
|
|
|
AioContext *aio_context = ctx->data;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
aio_context_acquire(aio_context);
|
2016-05-20 19:49:07 +03:00
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
2015-06-10 14:38:17 +03:00
|
|
|
if (aio_context == bdrv_get_aio_context(bs)) {
|
2016-10-27 13:48:53 +03:00
|
|
|
waited |= bdrv_drain_recurse(bs);
|
2015-06-10 14:38:17 +03:00
|
|
|
}
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
aio_context_release(aio_context);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-28 10:08:02 +03:00
|
|
|
g_slist_free(aio_ctxs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_drain_all_end(void)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs;
|
|
|
|
BdrvNextIterator it;
|
|
|
|
|
2016-05-20 19:49:07 +03:00
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
2015-04-28 16:27:52 +03:00
|
|
|
AioContext *aio_context = bdrv_get_aio_context(bs);
|
|
|
|
|
|
|
|
aio_context_acquire(aio_context);
|
2016-10-28 10:08:02 +03:00
|
|
|
aio_enable_external(aio_context);
|
2016-03-22 14:05:35 +03:00
|
|
|
bdrv_parent_drained_end(bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
aio_context_release(aio_context);
|
|
|
|
}
|
2016-05-27 13:53:36 +03:00
|
|
|
|
2017-05-08 17:13:03 +03:00
|
|
|
block_job_resume_all();
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-10-28 10:08:02 +03:00
|
|
|
void bdrv_drain_all(void)
|
|
|
|
{
|
|
|
|
bdrv_drain_all_begin();
|
|
|
|
bdrv_drain_all_end();
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
/**
|
|
|
|
* Remove an active request from the tracked requests list
|
|
|
|
*
|
|
|
|
* This function should be called when a tracked request is completing.
|
|
|
|
*/
|
|
|
|
static void tracked_request_end(BdrvTrackedRequest *req)
|
|
|
|
{
|
|
|
|
if (req->serialising) {
|
2017-06-05 15:38:53 +03:00
|
|
|
atomic_dec(&req->bs->serialising_in_flight);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_lock(&req->bs->reqs_lock);
|
2015-04-28 16:27:52 +03:00
|
|
|
QLIST_REMOVE(req, list);
|
|
|
|
qemu_co_queue_restart_all(&req->wait_queue);
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_unlock(&req->bs->reqs_lock);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add an active request to the tracked requests list
|
|
|
|
*/
|
|
|
|
static void tracked_request_begin(BdrvTrackedRequest *req,
|
|
|
|
BlockDriverState *bs,
|
|
|
|
int64_t offset,
|
2015-11-09 13:16:46 +03:00
|
|
|
unsigned int bytes,
|
|
|
|
enum BdrvTrackedRequestType type)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
*req = (BdrvTrackedRequest){
|
|
|
|
.bs = bs,
|
|
|
|
.offset = offset,
|
|
|
|
.bytes = bytes,
|
2015-11-09 13:16:46 +03:00
|
|
|
.type = type,
|
2015-04-28 16:27:52 +03:00
|
|
|
.co = qemu_coroutine_self(),
|
|
|
|
.serialising = false,
|
|
|
|
.overlap_offset = offset,
|
|
|
|
.overlap_bytes = bytes,
|
|
|
|
};
|
|
|
|
|
|
|
|
qemu_co_queue_init(&req->wait_queue);
|
|
|
|
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_lock(&bs->reqs_lock);
|
2015-04-28 16:27:52 +03:00
|
|
|
QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_unlock(&bs->reqs_lock);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
|
|
|
|
{
|
|
|
|
int64_t overlap_offset = req->offset & ~(align - 1);
|
|
|
|
unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
|
|
|
|
- overlap_offset;
|
|
|
|
|
|
|
|
if (!req->serialising) {
|
2017-06-05 15:38:53 +03:00
|
|
|
atomic_inc(&req->bs->serialising_in_flight);
|
2015-04-28 16:27:52 +03:00
|
|
|
req->serialising = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
|
|
|
|
req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
|
|
|
|
}
|
|
|
|
|
2016-06-02 12:41:52 +03:00
|
|
|
/**
|
|
|
|
* Round a region to cluster boundaries
|
|
|
|
*/
|
|
|
|
void bdrv_round_to_clusters(BlockDriverState *bs,
|
|
|
|
int64_t offset, unsigned int bytes,
|
|
|
|
int64_t *cluster_offset,
|
|
|
|
unsigned int *cluster_bytes)
|
|
|
|
{
|
|
|
|
BlockDriverInfo bdi;
|
|
|
|
|
|
|
|
if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
|
|
|
|
*cluster_offset = offset;
|
|
|
|
*cluster_bytes = bytes;
|
|
|
|
} else {
|
|
|
|
int64_t c = bdi.cluster_size;
|
|
|
|
*cluster_offset = QEMU_ALIGN_DOWN(offset, c);
|
|
|
|
*cluster_bytes = QEMU_ALIGN_UP(offset - *cluster_offset + bytes, c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
static int bdrv_get_cluster_size(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BlockDriverInfo bdi;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = bdrv_get_info(bs, &bdi);
|
|
|
|
if (ret < 0 || bdi.cluster_size == 0) {
|
2016-06-24 01:37:24 +03:00
|
|
|
return bs->bl.request_alignment;
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
|
|
|
return bdi.cluster_size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool tracked_request_overlaps(BdrvTrackedRequest *req,
|
|
|
|
int64_t offset, unsigned int bytes)
|
|
|
|
{
|
|
|
|
/* aaaa bbbb */
|
|
|
|
if (offset >= req->overlap_offset + req->overlap_bytes) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
/* bbbb aaaa */
|
|
|
|
if (req->overlap_offset >= offset + bytes) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
void bdrv_inc_in_flight(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
atomic_inc(&bs->in_flight);
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:49:05 +03:00
|
|
|
static void dummy_bh_cb(void *opaque)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_wakeup(BlockDriverState *bs)
|
|
|
|
{
|
2017-06-05 15:38:54 +03:00
|
|
|
/* The barrier (or an atomic op) is in the caller. */
|
|
|
|
if (atomic_read(&bs->wakeup)) {
|
2016-10-27 13:49:05 +03:00
|
|
|
aio_bh_schedule_oneshot(qemu_get_aio_context(), dummy_bh_cb, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
void bdrv_dec_in_flight(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
atomic_dec(&bs->in_flight);
|
2016-10-27 13:49:05 +03:00
|
|
|
bdrv_wakeup(bs);
|
2016-10-27 13:48:52 +03:00
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = self->bs;
|
|
|
|
BdrvTrackedRequest *req;
|
|
|
|
bool retry;
|
|
|
|
bool waited = false;
|
|
|
|
|
2017-06-05 15:38:53 +03:00
|
|
|
if (!atomic_read(&bs->serialising_in_flight)) {
|
2015-04-28 16:27:52 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
|
|
|
retry = false;
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_lock(&bs->reqs_lock);
|
2015-04-28 16:27:52 +03:00
|
|
|
QLIST_FOREACH(req, &bs->tracked_requests, list) {
|
|
|
|
if (req == self || (!req->serialising && !self->serialising)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (tracked_request_overlaps(req, self->overlap_offset,
|
|
|
|
self->overlap_bytes))
|
|
|
|
{
|
|
|
|
/* Hitting this means there was a reentrant request, for
|
|
|
|
* example, a block driver issuing nested requests. This must
|
|
|
|
* never happen since it means deadlock.
|
|
|
|
*/
|
|
|
|
assert(qemu_coroutine_self() != req->co);
|
|
|
|
|
|
|
|
/* If the request is already (indirectly) waiting for us, or
|
|
|
|
* will wait for us as soon as it wakes up, then just go on
|
|
|
|
* (instead of producing a deadlock in the former case). */
|
|
|
|
if (!req->waiting_for) {
|
|
|
|
self->waiting_for = req;
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_queue_wait(&req->wait_queue, &bs->reqs_lock);
|
2015-04-28 16:27:52 +03:00
|
|
|
self->waiting_for = NULL;
|
|
|
|
retry = true;
|
|
|
|
waited = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_unlock(&bs->reqs_lock);
|
2015-04-28 16:27:52 +03:00
|
|
|
} while (retry);
|
|
|
|
|
|
|
|
return waited;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
|
|
|
|
size_t size)
|
|
|
|
{
|
|
|
|
if (size > BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!bdrv_is_inserted(bs)) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (offset < 0) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct RwCo {
|
2016-05-30 16:00:40 +03:00
|
|
|
BdrvChild *child;
|
2015-04-28 16:27:52 +03:00
|
|
|
int64_t offset;
|
|
|
|
QEMUIOVector *qiov;
|
|
|
|
bool is_write;
|
|
|
|
int ret;
|
|
|
|
BdrvRequestFlags flags;
|
|
|
|
} RwCo;
|
|
|
|
|
|
|
|
static void coroutine_fn bdrv_rw_co_entry(void *opaque)
|
|
|
|
{
|
|
|
|
RwCo *rwco = opaque;
|
|
|
|
|
|
|
|
if (!rwco->is_write) {
|
2016-06-20 22:31:46 +03:00
|
|
|
rwco->ret = bdrv_co_preadv(rwco->child, rwco->offset,
|
2016-04-25 15:57:23 +03:00
|
|
|
rwco->qiov->size, rwco->qiov,
|
|
|
|
rwco->flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
2016-06-20 22:31:46 +03:00
|
|
|
rwco->ret = bdrv_co_pwritev(rwco->child, rwco->offset,
|
2016-04-25 15:57:23 +03:00
|
|
|
rwco->qiov->size, rwco->qiov,
|
|
|
|
rwco->flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a vectored synchronous request using coroutines
|
|
|
|
*/
|
2016-05-30 16:00:40 +03:00
|
|
|
static int bdrv_prwv_co(BdrvChild *child, int64_t offset,
|
2015-04-28 16:27:52 +03:00
|
|
|
QEMUIOVector *qiov, bool is_write,
|
|
|
|
BdrvRequestFlags flags)
|
|
|
|
{
|
|
|
|
Coroutine *co;
|
|
|
|
RwCo rwco = {
|
2016-05-30 16:00:40 +03:00
|
|
|
.child = child,
|
2015-04-28 16:27:52 +03:00
|
|
|
.offset = offset,
|
|
|
|
.qiov = qiov,
|
|
|
|
.is_write = is_write,
|
|
|
|
.ret = NOT_DONE,
|
|
|
|
.flags = flags,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
/* Fast-path if already in coroutine context */
|
|
|
|
bdrv_rw_co_entry(&rwco);
|
|
|
|
} else {
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 20:10:01 +03:00
|
|
|
co = qemu_coroutine_create(bdrv_rw_co_entry, &rwco);
|
block: Use bdrv_coroutine_enter to start I/O coroutines
BDRV_POLL_WHILE waits for the started I/O by releasing bs's ctx then polling
the main context, which relies on the yielded coroutine continuing on bs->ctx
before notifying qemu_aio_context with bdrv_wakeup().
Thus, using qemu_coroutine_enter to start I/O is wrong because if the coroutine
is entered from main loop, co->ctx will be qemu_aio_context, as a result of the
"release, poll, acquire" loop of BDRV_POLL_WHILE, race conditions happen when
both main thread and the iothread access the same BDS:
main loop iothread
-----------------------------------------------------------------------
blockdev_snapshot
aio_context_acquire(bs->ctx)
virtio_scsi_data_plane_handle_cmd
bdrv_drained_begin(bs->ctx)
bdrv_flush(bs)
bdrv_co_flush(bs) aio_context_acquire(bs->ctx).enter
...
qemu_coroutine_yield(co)
BDRV_POLL_WHILE()
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx).return
...
aio_co_wake(co)
aio_poll(qemu_aio_context) ...
co_schedule_bh_cb() ...
qemu_coroutine_enter(co) ...
/* (A) bdrv_co_flush(bs) /* (B) I/O on bs */
continues... */
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx)
Note that in above case, bdrv_drained_begin() doesn't do the "release,
poll, acquire" in BDRV_POLL_WHILE, because bs->in_flight == 0.
Fix this by using bdrv_coroutine_enter and enter coroutine in the right
context.
iotests 109 output is updated because the coroutine reenter flow during
mirror job complete is different (now through co_queue_wakeup, instead
of the unconditional qemu_coroutine_switch before), making the end job
len different.
Signed-off-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
2017-04-10 15:20:17 +03:00
|
|
|
bdrv_coroutine_enter(child->bs, co);
|
2016-10-27 13:48:55 +03:00
|
|
|
BDRV_POLL_WHILE(child->bs, rwco.ret == NOT_DONE);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
return rwco.ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a synchronous request using coroutines
|
|
|
|
*/
|
2016-05-30 16:00:40 +03:00
|
|
|
static int bdrv_rw_co(BdrvChild *child, int64_t sector_num, uint8_t *buf,
|
2015-04-28 16:27:52 +03:00
|
|
|
int nb_sectors, bool is_write, BdrvRequestFlags flags)
|
|
|
|
{
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_base = (void *)buf,
|
|
|
|
.iov_len = nb_sectors * BDRV_SECTOR_SIZE,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
2016-05-30 16:00:40 +03:00
|
|
|
return bdrv_prwv_co(child, sector_num << BDRV_SECTOR_BITS,
|
2015-04-28 16:27:52 +03:00
|
|
|
&qiov, is_write, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return < 0 if error. See bdrv_write() for the return codes */
|
2016-05-30 17:48:35 +03:00
|
|
|
int bdrv_read(BdrvChild *child, int64_t sector_num,
|
2015-04-28 16:27:52 +03:00
|
|
|
uint8_t *buf, int nb_sectors)
|
|
|
|
{
|
2016-05-30 16:00:40 +03:00
|
|
|
return bdrv_rw_co(child, sector_num, buf, nb_sectors, false, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Return < 0 if error. Important errors are:
|
|
|
|
-EIO generic I/O error (may happen for all errors)
|
|
|
|
-ENOMEDIUM No media inserted.
|
|
|
|
-EINVAL Invalid sector number or nb_sectors
|
|
|
|
-EACCES Trying to write a read-only device
|
|
|
|
*/
|
2016-05-31 15:42:08 +03:00
|
|
|
int bdrv_write(BdrvChild *child, int64_t sector_num,
|
2015-04-28 16:27:52 +03:00
|
|
|
const uint8_t *buf, int nb_sectors)
|
|
|
|
{
|
2016-05-30 16:00:40 +03:00
|
|
|
return bdrv_rw_co(child, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-06-16 16:13:15 +03:00
|
|
|
int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
|
2017-06-09 13:18:08 +03:00
|
|
|
int bytes, BdrvRequestFlags flags)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2016-06-02 00:10:04 +03:00
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_base = NULL,
|
2017-06-09 13:18:08 +03:00
|
|
|
.iov_len = bytes,
|
2016-06-02 00:10:04 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
2016-05-30 16:00:40 +03:00
|
|
|
return bdrv_prwv_co(child, offset, &qiov, true,
|
2016-06-02 00:10:04 +03:00
|
|
|
BDRV_REQ_ZERO_WRITE | flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-06-02 00:10:04 +03:00
|
|
|
* Completely zero out a block device with the help of bdrv_pwrite_zeroes.
|
2015-04-28 16:27:52 +03:00
|
|
|
* The operation is sped up by checking the block status and only writing
|
|
|
|
* zeroes to the device if they currently do not return zeroes. Optional
|
2016-06-02 00:10:04 +03:00
|
|
|
* flags are passed through to bdrv_pwrite_zeroes (e.g. BDRV_REQ_MAY_UNMAP,
|
block: Honor BDRV_REQ_FUA during write_zeroes
The block layer has a couple of cases where it can lose
Force Unit Access semantics when writing a large block of
zeroes, such that the request returns before the zeroes
have been guaranteed to land on underlying media.
SCSI does not support FUA during WRITESAME(10/16); FUA is only
supported if it falls back to WRITE(10/16). But where the
underlying device is new enough to not need a fallback, it
means that any upper layer request with FUA semantics was
silently ignoring BDRV_REQ_FUA.
Conversely, NBD has situations where it can support FUA but not
ZERO_WRITE; when that happens, the generic block layer fallback
to bdrv_driver_pwritev() (or the older bdrv_co_writev() in qemu
2.6) was losing the FUA flag.
The problem of losing flags unrelated to ZERO_WRITE has been
latent in bdrv_co_do_write_zeroes() since commit aa7bfbff, but
back then, it did not matter because there was no FUA flag. It
became observable when commit 93f5e6d8 paved the way for flags
that can impact correctness, when we should have been using
bdrv_co_writev_flags() with modified flags. Compare to commit
9eeb6dd, which got flag manipulation right in
bdrv_co_do_zero_pwritev().
Symptoms: I tested with qemu-io with default writethrough cache
(which is supposed to use FUA semantics on every write), and
targetted an NBD client connected to a server that intentionally
did not advertise NBD_FLAG_SEND_FUA. When doing 'write 0 512',
the NBD client sent two operations (NBD_CMD_WRITE then
NBD_CMD_FLUSH) to get the fallback FUA semantics; but when doing
'write -z 0 512', the NBD client sent only NBD_CMD_WRITE.
The fix is do to a cleanup bdrv_co_flush() at the end of the
operation if any step in the middle relied on a BDS that does
not natively support FUA for that step (note that we don't
need to flush after every operation, if the operation is broken
into chunks based on bounce-buffer sizing). Each BDS gains a
new flag .supported_zero_flags, which parallels the use of
.supported_write_flags but only when accessing a zero write
operation (the flags MUST be different, because of SCSI having
different semantics based on WRITE vs. WRITESAME; and also
because BDRV_REQ_MAY_UNMAP only makes sense on zero writes).
Also fix some documentation to describe -ENOTSUP semantics,
particularly since iscsi depends on those semantics.
Down the road, we may want to add a driver where its
.bdrv_co_pwritev() honors all three of BDRV_REQ_FUA,
BDRV_REQ_ZERO_WRITE, and BDRV_REQ_MAY_UNMAP, and advertise
this via bs->supported_write_flags for blocks opened by that
driver; such a driver should NOT supply .bdrv_co_write_zeroes
nor .supported_zero_flags. But none of the drivers touched
in this patch want to do that (the act of writing zeroes is
different enough from normal writes to deserve a second
callback).
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-04 01:39:07 +03:00
|
|
|
* BDRV_REQ_FUA).
|
2015-04-28 16:27:52 +03:00
|
|
|
*
|
|
|
|
* Returns < 0 on error, 0 on success. For error codes see bdrv_write().
|
|
|
|
*/
|
2016-06-16 16:13:15 +03:00
|
|
|
int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
int64_t target_sectors, ret, nb_sectors, sector_num = 0;
|
2016-06-16 16:13:15 +03:00
|
|
|
BlockDriverState *bs = child->bs;
|
2016-01-26 06:58:48 +03:00
|
|
|
BlockDriverState *file;
|
2015-04-28 16:27:52 +03:00
|
|
|
int n;
|
|
|
|
|
|
|
|
target_sectors = bdrv_nb_sectors(bs);
|
|
|
|
if (target_sectors < 0) {
|
|
|
|
return target_sectors;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
nb_sectors = MIN(target_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
|
|
|
|
if (nb_sectors <= 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
2016-01-26 06:58:48 +03:00
|
|
|
ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n, &file);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error getting block status at sector %" PRId64 ": %s",
|
|
|
|
sector_num, strerror(-ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
if (ret & BDRV_BLOCK_ZERO) {
|
|
|
|
sector_num += n;
|
|
|
|
continue;
|
|
|
|
}
|
2016-06-16 16:13:15 +03:00
|
|
|
ret = bdrv_pwrite_zeroes(child, sector_num << BDRV_SECTOR_BITS,
|
2016-06-02 00:10:04 +03:00
|
|
|
n << BDRV_SECTOR_BITS, flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error writing zeroes at sector %" PRId64 ": %s",
|
|
|
|
sector_num, strerror(-ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
sector_num += n;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-20 19:24:02 +03:00
|
|
|
int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov)
|
2016-06-09 17:36:00 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2016-05-30 16:00:40 +03:00
|
|
|
ret = bdrv_prwv_co(child, offset, qiov, false, 0);
|
2016-06-09 17:36:00 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return qiov->size;
|
|
|
|
}
|
|
|
|
|
2016-06-20 19:24:02 +03:00
|
|
|
int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int bytes)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_base = (void *)buf,
|
|
|
|
.iov_len = bytes,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (bytes < 0) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
2016-06-20 19:24:02 +03:00
|
|
|
return bdrv_preadv(child, offset, &qiov);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-06-20 21:09:15 +03:00
|
|
|
int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2016-05-30 16:00:40 +03:00
|
|
|
ret = bdrv_prwv_co(child, offset, qiov, true, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return qiov->size;
|
|
|
|
}
|
|
|
|
|
2016-06-20 21:09:15 +03:00
|
|
|
int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_base = (void *) buf,
|
|
|
|
.iov_len = bytes,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (bytes < 0) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
2016-06-20 21:09:15 +03:00
|
|
|
return bdrv_pwritev(child, offset, &qiov);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Writes to the file and ensures that no writes are reordered across this
|
|
|
|
* request (acts as a barrier)
|
|
|
|
*
|
|
|
|
* Returns 0 on success, -errno in error cases.
|
|
|
|
*/
|
2016-06-20 21:09:15 +03:00
|
|
|
int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
|
|
|
|
const void *buf, int count)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2016-06-20 21:09:15 +03:00
|
|
|
ret = bdrv_pwrite(child, offset, buf, count);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-06-20 21:09:15 +03:00
|
|
|
ret = bdrv_flush(child->bs);
|
2016-03-04 16:16:51 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-25 15:13:12 +03:00
|
|
|
typedef struct CoroutineIOCompletion {
|
|
|
|
Coroutine *coroutine;
|
|
|
|
int ret;
|
|
|
|
} CoroutineIOCompletion;
|
|
|
|
|
|
|
|
static void bdrv_co_io_em_complete(void *opaque, int ret)
|
|
|
|
{
|
|
|
|
CoroutineIOCompletion *co = opaque;
|
|
|
|
|
|
|
|
co->ret = ret;
|
2017-02-13 16:52:32 +03:00
|
|
|
aio_co_wake(co->coroutine);
|
2016-04-25 15:13:12 +03:00
|
|
|
}
|
|
|
|
|
2016-04-25 12:46:41 +03:00
|
|
|
static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
|
|
|
|
uint64_t offset, uint64_t bytes,
|
|
|
|
QEMUIOVector *qiov, int flags)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
2016-04-25 12:25:18 +03:00
|
|
|
int64_t sector_num;
|
|
|
|
unsigned int nb_sectors;
|
|
|
|
|
2016-06-13 21:56:35 +03:00
|
|
|
assert(!(flags & ~BDRV_REQ_MASK));
|
|
|
|
|
2016-04-25 12:25:18 +03:00
|
|
|
if (drv->bdrv_co_preadv) {
|
|
|
|
return drv->bdrv_co_preadv(bs, offset, bytes, qiov, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
sector_num = offset >> BDRV_SECTOR_BITS;
|
|
|
|
nb_sectors = bytes >> BDRV_SECTOR_BITS;
|
2016-04-25 12:46:41 +03:00
|
|
|
|
|
|
|
assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
|
|
|
|
assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
|
|
|
|
assert((bytes >> BDRV_SECTOR_BITS) <= BDRV_REQUEST_MAX_SECTORS);
|
|
|
|
|
2016-04-25 15:13:12 +03:00
|
|
|
if (drv->bdrv_co_readv) {
|
|
|
|
return drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
|
|
|
|
} else {
|
|
|
|
BlockAIOCB *acb;
|
|
|
|
CoroutineIOCompletion co = {
|
|
|
|
.coroutine = qemu_coroutine_self(),
|
|
|
|
};
|
|
|
|
|
|
|
|
acb = bs->drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
|
|
|
|
bdrv_co_io_em_complete, &co);
|
|
|
|
if (acb == NULL) {
|
|
|
|
return -EIO;
|
|
|
|
} else {
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
return co.ret;
|
|
|
|
}
|
|
|
|
}
|
2016-04-25 12:46:41 +03:00
|
|
|
}
|
|
|
|
|
2016-04-25 13:13:39 +03:00
|
|
|
static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs,
|
|
|
|
uint64_t offset, uint64_t bytes,
|
|
|
|
QEMUIOVector *qiov, int flags)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
2016-04-25 12:25:18 +03:00
|
|
|
int64_t sector_num;
|
|
|
|
unsigned int nb_sectors;
|
2016-04-25 13:13:39 +03:00
|
|
|
int ret;
|
|
|
|
|
2016-06-13 21:56:35 +03:00
|
|
|
assert(!(flags & ~BDRV_REQ_MASK));
|
|
|
|
|
2016-04-25 12:25:18 +03:00
|
|
|
if (drv->bdrv_co_pwritev) {
|
2016-06-07 16:51:28 +03:00
|
|
|
ret = drv->bdrv_co_pwritev(bs, offset, bytes, qiov,
|
|
|
|
flags & bs->supported_write_flags);
|
|
|
|
flags &= ~bs->supported_write_flags;
|
2016-04-25 12:25:18 +03:00
|
|
|
goto emulate_flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
sector_num = offset >> BDRV_SECTOR_BITS;
|
|
|
|
nb_sectors = bytes >> BDRV_SECTOR_BITS;
|
|
|
|
|
2016-04-25 13:13:39 +03:00
|
|
|
assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
|
|
|
|
assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
|
|
|
|
assert((bytes >> BDRV_SECTOR_BITS) <= BDRV_REQUEST_MAX_SECTORS);
|
|
|
|
|
|
|
|
if (drv->bdrv_co_writev_flags) {
|
|
|
|
ret = drv->bdrv_co_writev_flags(bs, sector_num, nb_sectors, qiov,
|
2016-05-04 01:39:06 +03:00
|
|
|
flags & bs->supported_write_flags);
|
|
|
|
flags &= ~bs->supported_write_flags;
|
2016-04-25 15:13:12 +03:00
|
|
|
} else if (drv->bdrv_co_writev) {
|
2016-05-04 01:39:06 +03:00
|
|
|
assert(!bs->supported_write_flags);
|
2016-04-25 13:13:39 +03:00
|
|
|
ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
|
2016-04-25 15:13:12 +03:00
|
|
|
} else {
|
|
|
|
BlockAIOCB *acb;
|
|
|
|
CoroutineIOCompletion co = {
|
|
|
|
.coroutine = qemu_coroutine_self(),
|
|
|
|
};
|
|
|
|
|
|
|
|
acb = bs->drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
|
|
|
|
bdrv_co_io_em_complete, &co);
|
|
|
|
if (acb == NULL) {
|
2016-04-25 12:25:18 +03:00
|
|
|
ret = -EIO;
|
2016-04-25 15:13:12 +03:00
|
|
|
} else {
|
|
|
|
qemu_coroutine_yield();
|
2016-04-25 12:25:18 +03:00
|
|
|
ret = co.ret;
|
2016-04-25 15:13:12 +03:00
|
|
|
}
|
2016-04-25 13:13:39 +03:00
|
|
|
}
|
|
|
|
|
2016-04-25 12:25:18 +03:00
|
|
|
emulate_flags:
|
2016-05-04 01:39:06 +03:00
|
|
|
if (ret == 0 && (flags & BDRV_REQ_FUA)) {
|
2016-04-25 13:13:39 +03:00
|
|
|
ret = bdrv_co_flush(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-07-22 11:17:42 +03:00
|
|
|
static int coroutine_fn
|
|
|
|
bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
|
|
|
|
uint64_t bytes, QEMUIOVector *qiov)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
|
|
|
|
if (!drv->bdrv_co_pwritev_compressed) {
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
return drv->bdrv_co_pwritev_compressed(bs, offset, bytes, qiov);
|
|
|
|
}
|
|
|
|
|
2017-02-09 17:58:43 +03:00
|
|
|
static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
|
2016-06-02 12:41:52 +03:00
|
|
|
int64_t offset, unsigned int bytes, QEMUIOVector *qiov)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2017-02-09 17:58:43 +03:00
|
|
|
BlockDriverState *bs = child->bs;
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
/* Perform I/O through a temporary buffer so that users who scribble over
|
|
|
|
* their read buffer while the operation is in progress do not end up
|
|
|
|
* modifying the image file. This is critical for zero-copy guest I/O
|
|
|
|
* where anything might happen inside guest memory.
|
|
|
|
*/
|
|
|
|
void *bounce_buffer;
|
|
|
|
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
struct iovec iov;
|
|
|
|
QEMUIOVector bounce_qiov;
|
2016-06-02 12:41:52 +03:00
|
|
|
int64_t cluster_offset;
|
|
|
|
unsigned int cluster_bytes;
|
2015-04-28 16:27:52 +03:00
|
|
|
size_t skip_bytes;
|
|
|
|
int ret;
|
|
|
|
|
2017-04-07 13:29:05 +03:00
|
|
|
/* FIXME We cannot require callers to have write permissions when all they
|
|
|
|
* are doing is a read request. If we did things right, write permissions
|
|
|
|
* would be obtained anyway, but internally by the copy-on-read code. As
|
|
|
|
* long as it is implemented here rather than in a separat filter driver,
|
|
|
|
* the copy-on-read code doesn't have its own BdrvChild, however, for which
|
|
|
|
* it could request permissions. Therefore we have to bypass the permission
|
|
|
|
* system for the moment. */
|
|
|
|
// assert(child->perm & (BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE));
|
2017-02-09 18:49:53 +03:00
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
/* Cover entire cluster so no additional backing file I/O is required when
|
|
|
|
* allocating cluster in the image file.
|
|
|
|
*/
|
2016-06-02 12:41:52 +03:00
|
|
|
bdrv_round_to_clusters(bs, offset, bytes, &cluster_offset, &cluster_bytes);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-06-02 12:41:52 +03:00
|
|
|
trace_bdrv_co_do_copy_on_readv(bs, offset, bytes,
|
|
|
|
cluster_offset, cluster_bytes);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-06-02 12:41:52 +03:00
|
|
|
iov.iov_len = cluster_bytes;
|
2015-04-28 16:27:52 +03:00
|
|
|
iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);
|
|
|
|
if (bounce_buffer == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_iovec_init_external(&bounce_qiov, &iov, 1);
|
|
|
|
|
2016-06-02 12:41:52 +03:00
|
|
|
ret = bdrv_driver_preadv(bs, cluster_offset, cluster_bytes,
|
2016-04-25 12:46:41 +03:00
|
|
|
&bounce_qiov, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2016-06-02 00:10:13 +03:00
|
|
|
if (drv->bdrv_co_pwrite_zeroes &&
|
2015-04-28 16:27:52 +03:00
|
|
|
buffer_is_zero(bounce_buffer, iov.iov_len)) {
|
2016-06-24 01:37:06 +03:00
|
|
|
/* FIXME: Should we (perhaps conditionally) be setting
|
|
|
|
* BDRV_REQ_MAY_UNMAP, if it will allow for a sparser copy
|
|
|
|
* that still correctly reads as zero? */
|
2016-06-02 12:41:52 +03:00
|
|
|
ret = bdrv_co_do_pwrite_zeroes(bs, cluster_offset, cluster_bytes, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
|
|
|
/* This does not change the data on the disk, it is not necessary
|
|
|
|
* to flush even in cache=writethrough mode.
|
|
|
|
*/
|
2016-06-02 12:41:52 +03:00
|
|
|
ret = bdrv_driver_pwritev(bs, cluster_offset, cluster_bytes,
|
2016-04-25 13:13:39 +03:00
|
|
|
&bounce_qiov, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
/* It might be okay to ignore write errors for guest requests. If this
|
|
|
|
* is a deliberate copy-on-read then we don't want to ignore the error.
|
|
|
|
* Simply report it in all cases.
|
|
|
|
*/
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2016-06-02 12:41:52 +03:00
|
|
|
skip_bytes = offset - cluster_offset;
|
|
|
|
qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes, bytes);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
err:
|
|
|
|
qemu_vfree(bounce_buffer);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Forwards an already correctly aligned request to the BlockDriver. This
|
2016-07-15 21:31:59 +03:00
|
|
|
* handles copy on read, zeroing after EOF, and fragmentation of large
|
|
|
|
* reads; any other features must be implemented by the caller.
|
2015-04-28 16:27:52 +03:00
|
|
|
*/
|
2017-02-09 17:58:43 +03:00
|
|
|
static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
|
2015-04-28 16:27:52 +03:00
|
|
|
BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
|
|
|
|
int64_t align, QEMUIOVector *qiov, int flags)
|
|
|
|
{
|
2017-02-09 17:58:43 +03:00
|
|
|
BlockDriverState *bs = child->bs;
|
2016-06-01 18:13:47 +03:00
|
|
|
int64_t total_bytes, max_bytes;
|
2016-07-15 21:31:59 +03:00
|
|
|
int ret = 0;
|
|
|
|
uint64_t bytes_remaining = bytes;
|
|
|
|
int max_transfer;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-06-03 17:17:28 +03:00
|
|
|
assert(is_power_of_2(align));
|
|
|
|
assert((offset & (align - 1)) == 0);
|
|
|
|
assert((bytes & (align - 1)) == 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
assert(!qiov || bytes == qiov->size);
|
2016-03-21 17:11:42 +03:00
|
|
|
assert((bs->open_flags & BDRV_O_NO_IO) == 0);
|
2016-07-15 21:31:59 +03:00
|
|
|
max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),
|
|
|
|
align);
|
2016-06-24 01:37:06 +03:00
|
|
|
|
|
|
|
/* TODO: We would need a per-BDS .supported_read_flags and
|
|
|
|
* potential fallback support, if we ever implement any read flags
|
|
|
|
* to pass through to drivers. For now, there aren't any
|
|
|
|
* passthrough flags. */
|
|
|
|
assert(!(flags & ~(BDRV_REQ_NO_SERIALISING | BDRV_REQ_COPY_ON_READ)));
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
/* Handle Copy on Read and associated serialisation */
|
|
|
|
if (flags & BDRV_REQ_COPY_ON_READ) {
|
|
|
|
/* If we touch the same cluster it counts as an overlap. This
|
|
|
|
* guarantees that allocating writes will be serialized and not race
|
|
|
|
* with each other for the same cluster. For example, in copy-on-read
|
|
|
|
* it ensures that the CoR read and write operations are atomic and
|
|
|
|
* guest writes cannot interleave between them. */
|
|
|
|
mark_request_serialising(req, bdrv_get_cluster_size(bs));
|
|
|
|
}
|
|
|
|
|
2015-12-01 12:36:28 +03:00
|
|
|
if (!(flags & BDRV_REQ_NO_SERIALISING)) {
|
|
|
|
wait_serialising_requests(req);
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
if (flags & BDRV_REQ_COPY_ON_READ) {
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
/* TODO: Simplify further once bdrv_is_allocated no longer
|
|
|
|
* requires sector alignment */
|
|
|
|
int64_t start = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);
|
|
|
|
int64_t end = QEMU_ALIGN_UP(offset + bytes, BDRV_SECTOR_SIZE);
|
|
|
|
int64_t pnum;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
ret = bdrv_is_allocated(bs, start, end - start, &pnum);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
if (!ret || pnum != end - start) {
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov);
|
2015-04-28 16:27:52 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-15 21:31:59 +03:00
|
|
|
/* Forward the request to the BlockDriver, possibly fragmenting it */
|
2016-06-01 18:13:47 +03:00
|
|
|
total_bytes = bdrv_getlength(bs);
|
|
|
|
if (total_bytes < 0) {
|
|
|
|
ret = total_bytes;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-06-01 18:13:47 +03:00
|
|
|
max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);
|
2016-07-15 21:31:59 +03:00
|
|
|
if (bytes <= max_bytes && bytes <= max_transfer) {
|
2016-06-01 18:13:47 +03:00
|
|
|
ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0);
|
2016-07-15 21:31:59 +03:00
|
|
|
goto out;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-07-15 21:31:59 +03:00
|
|
|
while (bytes_remaining) {
|
|
|
|
int num;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-07-15 21:31:59 +03:00
|
|
|
if (max_bytes) {
|
|
|
|
QEMUIOVector local_qiov;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-07-15 21:31:59 +03:00
|
|
|
num = MIN(bytes_remaining, MIN(max_bytes, max_transfer));
|
|
|
|
assert(num);
|
|
|
|
qemu_iovec_init(&local_qiov, qiov->niov);
|
|
|
|
qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-07-15 21:31:59 +03:00
|
|
|
ret = bdrv_driver_preadv(bs, offset + bytes - bytes_remaining,
|
|
|
|
num, &local_qiov, 0);
|
|
|
|
max_bytes -= num;
|
|
|
|
qemu_iovec_destroy(&local_qiov);
|
|
|
|
} else {
|
|
|
|
num = bytes_remaining;
|
|
|
|
ret = qemu_iovec_memset(qiov, bytes - bytes_remaining, 0,
|
|
|
|
bytes_remaining);
|
|
|
|
}
|
|
|
|
if (ret < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
bytes_remaining -= num;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2016-07-15 21:31:59 +03:00
|
|
|
return ret < 0 ? ret : 0;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle a read request in coroutine context
|
|
|
|
*/
|
2016-06-20 22:31:46 +03:00
|
|
|
int coroutine_fn bdrv_co_preadv(BdrvChild *child,
|
2015-04-28 16:27:52 +03:00
|
|
|
int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
|
|
|
|
BdrvRequestFlags flags)
|
|
|
|
{
|
2016-06-20 22:31:46 +03:00
|
|
|
BlockDriverState *bs = child->bs;
|
2015-04-28 16:27:52 +03:00
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
BdrvTrackedRequest req;
|
|
|
|
|
2016-06-24 01:37:24 +03:00
|
|
|
uint64_t align = bs->bl.request_alignment;
|
2015-04-28 16:27:52 +03:00
|
|
|
uint8_t *head_buf = NULL;
|
|
|
|
uint8_t *tail_buf = NULL;
|
|
|
|
QEMUIOVector local_qiov;
|
|
|
|
bool use_local_qiov = false;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!drv) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = bdrv_check_byte_request(bs, offset, bytes);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_inc_in_flight(bs);
|
|
|
|
|
2015-09-08 06:28:32 +03:00
|
|
|
/* Don't do copy-on-read if we read data before write operation */
|
2017-06-05 15:38:50 +03:00
|
|
|
if (atomic_read(&bs->copy_on_read) && !(flags & BDRV_REQ_NO_SERIALISING)) {
|
2015-04-28 16:27:52 +03:00
|
|
|
flags |= BDRV_REQ_COPY_ON_READ;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Align read if necessary by padding qiov */
|
|
|
|
if (offset & (align - 1)) {
|
|
|
|
head_buf = qemu_blockalign(bs, align);
|
|
|
|
qemu_iovec_init(&local_qiov, qiov->niov + 2);
|
|
|
|
qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
|
|
|
|
qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
|
|
|
|
use_local_qiov = true;
|
|
|
|
|
|
|
|
bytes += offset & (align - 1);
|
|
|
|
offset = offset & ~(align - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((offset + bytes) & (align - 1)) {
|
|
|
|
if (!use_local_qiov) {
|
|
|
|
qemu_iovec_init(&local_qiov, qiov->niov + 1);
|
|
|
|
qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
|
|
|
|
use_local_qiov = true;
|
|
|
|
}
|
|
|
|
tail_buf = qemu_blockalign(bs, align);
|
|
|
|
qemu_iovec_add(&local_qiov, tail_buf,
|
|
|
|
align - ((offset + bytes) & (align - 1)));
|
|
|
|
|
|
|
|
bytes = ROUND_UP(bytes, align);
|
|
|
|
}
|
|
|
|
|
2015-11-09 13:16:46 +03:00
|
|
|
tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_READ);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_preadv(child, &req, offset, bytes, align,
|
2015-04-28 16:27:52 +03:00
|
|
|
use_local_qiov ? &local_qiov : qiov,
|
|
|
|
flags);
|
|
|
|
tracked_request_end(&req);
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_dec_in_flight(bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
if (use_local_qiov) {
|
|
|
|
qemu_iovec_destroy(&local_qiov);
|
|
|
|
qemu_vfree(head_buf);
|
|
|
|
qemu_vfree(tail_buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-30 14:52:34 +03:00
|
|
|
static int coroutine_fn bdrv_co_do_readv(BdrvChild *child,
|
2015-04-28 16:27:52 +03:00
|
|
|
int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
|
|
|
|
BdrvRequestFlags flags)
|
|
|
|
{
|
|
|
|
if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-06-20 22:31:46 +03:00
|
|
|
return bdrv_co_preadv(child, sector_num << BDRV_SECTOR_BITS,
|
2016-04-25 15:57:23 +03:00
|
|
|
nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-05-24 18:21:22 +03:00
|
|
|
int coroutine_fn bdrv_co_readv(BdrvChild *child, int64_t sector_num,
|
|
|
|
int nb_sectors, QEMUIOVector *qiov)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2016-05-24 18:21:22 +03:00
|
|
|
trace_bdrv_co_readv(child->bs, sector_num, nb_sectors);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-05-30 14:52:34 +03:00
|
|
|
return bdrv_co_do_readv(child, sector_num, nb_sectors, qiov, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-06-24 01:37:19 +03:00
|
|
|
/* Maximum buffer for write zeroes fallback, in bytes */
|
|
|
|
#define MAX_WRITE_ZEROES_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-06-02 00:10:03 +03:00
|
|
|
static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
|
2017-06-09 13:18:08 +03:00
|
|
|
int64_t offset, int bytes, BdrvRequestFlags flags)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {0};
|
|
|
|
int ret = 0;
|
block: Honor BDRV_REQ_FUA during write_zeroes
The block layer has a couple of cases where it can lose
Force Unit Access semantics when writing a large block of
zeroes, such that the request returns before the zeroes
have been guaranteed to land on underlying media.
SCSI does not support FUA during WRITESAME(10/16); FUA is only
supported if it falls back to WRITE(10/16). But where the
underlying device is new enough to not need a fallback, it
means that any upper layer request with FUA semantics was
silently ignoring BDRV_REQ_FUA.
Conversely, NBD has situations where it can support FUA but not
ZERO_WRITE; when that happens, the generic block layer fallback
to bdrv_driver_pwritev() (or the older bdrv_co_writev() in qemu
2.6) was losing the FUA flag.
The problem of losing flags unrelated to ZERO_WRITE has been
latent in bdrv_co_do_write_zeroes() since commit aa7bfbff, but
back then, it did not matter because there was no FUA flag. It
became observable when commit 93f5e6d8 paved the way for flags
that can impact correctness, when we should have been using
bdrv_co_writev_flags() with modified flags. Compare to commit
9eeb6dd, which got flag manipulation right in
bdrv_co_do_zero_pwritev().
Symptoms: I tested with qemu-io with default writethrough cache
(which is supposed to use FUA semantics on every write), and
targetted an NBD client connected to a server that intentionally
did not advertise NBD_FLAG_SEND_FUA. When doing 'write 0 512',
the NBD client sent two operations (NBD_CMD_WRITE then
NBD_CMD_FLUSH) to get the fallback FUA semantics; but when doing
'write -z 0 512', the NBD client sent only NBD_CMD_WRITE.
The fix is do to a cleanup bdrv_co_flush() at the end of the
operation if any step in the middle relied on a BDS that does
not natively support FUA for that step (note that we don't
need to flush after every operation, if the operation is broken
into chunks based on bounce-buffer sizing). Each BDS gains a
new flag .supported_zero_flags, which parallels the use of
.supported_write_flags but only when accessing a zero write
operation (the flags MUST be different, because of SCSI having
different semantics based on WRITE vs. WRITESAME; and also
because BDRV_REQ_MAY_UNMAP only makes sense on zero writes).
Also fix some documentation to describe -ENOTSUP semantics,
particularly since iscsi depends on those semantics.
Down the road, we may want to add a driver where its
.bdrv_co_pwritev() honors all three of BDRV_REQ_FUA,
BDRV_REQ_ZERO_WRITE, and BDRV_REQ_MAY_UNMAP, and advertise
this via bs->supported_write_flags for blocks opened by that
driver; such a driver should NOT supply .bdrv_co_write_zeroes
nor .supported_zero_flags. But none of the drivers touched
in this patch want to do that (the act of writing zeroes is
different enough from normal writes to deserve a second
callback).
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-04 01:39:07 +03:00
|
|
|
bool need_flush = false;
|
2016-05-26 06:48:45 +03:00
|
|
|
int head = 0;
|
|
|
|
int tail = 0;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-06-02 00:10:02 +03:00
|
|
|
int max_write_zeroes = MIN_NON_ZERO(bs->bl.max_pwrite_zeroes, INT_MAX);
|
2016-06-24 01:37:24 +03:00
|
|
|
int alignment = MAX(bs->bl.pwrite_zeroes_alignment,
|
|
|
|
bs->bl.request_alignment);
|
2016-11-17 23:13:56 +03:00
|
|
|
int max_transfer = MIN_NON_ZERO(bs->bl.max_transfer,
|
|
|
|
MAX_WRITE_ZEROES_BOUNCE_BUFFER);
|
2016-06-02 00:10:03 +03:00
|
|
|
|
2016-07-21 22:34:48 +03:00
|
|
|
assert(alignment % bs->bl.request_alignment == 0);
|
|
|
|
head = offset % alignment;
|
2017-06-09 13:18:08 +03:00
|
|
|
tail = (offset + bytes) % alignment;
|
2016-07-21 22:34:48 +03:00
|
|
|
max_write_zeroes = QEMU_ALIGN_DOWN(max_write_zeroes, alignment);
|
|
|
|
assert(max_write_zeroes >= bs->bl.request_alignment);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-06-09 13:18:08 +03:00
|
|
|
while (bytes > 0 && !ret) {
|
|
|
|
int num = bytes;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
/* Align request. Block drivers can expect the "bulk" of the request
|
2016-05-26 06:48:45 +03:00
|
|
|
* to be aligned, and that unaligned requests do not cross cluster
|
|
|
|
* boundaries.
|
2015-04-28 16:27:52 +03:00
|
|
|
*/
|
2016-05-26 06:48:45 +03:00
|
|
|
if (head) {
|
2016-11-17 23:13:56 +03:00
|
|
|
/* Make a small request up to the first aligned sector. For
|
|
|
|
* convenience, limit this request to max_transfer even if
|
|
|
|
* we don't need to fall back to writes. */
|
2017-06-09 13:18:08 +03:00
|
|
|
num = MIN(MIN(bytes, max_transfer), alignment - head);
|
2016-11-17 23:13:56 +03:00
|
|
|
head = (head + num) % alignment;
|
|
|
|
assert(num < max_write_zeroes);
|
2016-06-02 00:10:03 +03:00
|
|
|
} else if (tail && num > alignment) {
|
2016-05-26 06:48:45 +03:00
|
|
|
/* Shorten the request to the last aligned sector. */
|
|
|
|
num -= tail;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* limit request size */
|
|
|
|
if (num > max_write_zeroes) {
|
|
|
|
num = max_write_zeroes;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = -ENOTSUP;
|
|
|
|
/* First try the efficient write zeroes operation */
|
2016-06-02 00:10:03 +03:00
|
|
|
if (drv->bdrv_co_pwrite_zeroes) {
|
|
|
|
ret = drv->bdrv_co_pwrite_zeroes(bs, offset, num,
|
|
|
|
flags & bs->supported_zero_flags);
|
|
|
|
if (ret != -ENOTSUP && (flags & BDRV_REQ_FUA) &&
|
|
|
|
!(bs->supported_zero_flags & BDRV_REQ_FUA)) {
|
|
|
|
need_flush = true;
|
|
|
|
}
|
block: Honor BDRV_REQ_FUA during write_zeroes
The block layer has a couple of cases where it can lose
Force Unit Access semantics when writing a large block of
zeroes, such that the request returns before the zeroes
have been guaranteed to land on underlying media.
SCSI does not support FUA during WRITESAME(10/16); FUA is only
supported if it falls back to WRITE(10/16). But where the
underlying device is new enough to not need a fallback, it
means that any upper layer request with FUA semantics was
silently ignoring BDRV_REQ_FUA.
Conversely, NBD has situations where it can support FUA but not
ZERO_WRITE; when that happens, the generic block layer fallback
to bdrv_driver_pwritev() (or the older bdrv_co_writev() in qemu
2.6) was losing the FUA flag.
The problem of losing flags unrelated to ZERO_WRITE has been
latent in bdrv_co_do_write_zeroes() since commit aa7bfbff, but
back then, it did not matter because there was no FUA flag. It
became observable when commit 93f5e6d8 paved the way for flags
that can impact correctness, when we should have been using
bdrv_co_writev_flags() with modified flags. Compare to commit
9eeb6dd, which got flag manipulation right in
bdrv_co_do_zero_pwritev().
Symptoms: I tested with qemu-io with default writethrough cache
(which is supposed to use FUA semantics on every write), and
targetted an NBD client connected to a server that intentionally
did not advertise NBD_FLAG_SEND_FUA. When doing 'write 0 512',
the NBD client sent two operations (NBD_CMD_WRITE then
NBD_CMD_FLUSH) to get the fallback FUA semantics; but when doing
'write -z 0 512', the NBD client sent only NBD_CMD_WRITE.
The fix is do to a cleanup bdrv_co_flush() at the end of the
operation if any step in the middle relied on a BDS that does
not natively support FUA for that step (note that we don't
need to flush after every operation, if the operation is broken
into chunks based on bounce-buffer sizing). Each BDS gains a
new flag .supported_zero_flags, which parallels the use of
.supported_write_flags but only when accessing a zero write
operation (the flags MUST be different, because of SCSI having
different semantics based on WRITE vs. WRITESAME; and also
because BDRV_REQ_MAY_UNMAP only makes sense on zero writes).
Also fix some documentation to describe -ENOTSUP semantics,
particularly since iscsi depends on those semantics.
Down the road, we may want to add a driver where its
.bdrv_co_pwritev() honors all three of BDRV_REQ_FUA,
BDRV_REQ_ZERO_WRITE, and BDRV_REQ_MAY_UNMAP, and advertise
this via bs->supported_write_flags for blocks opened by that
driver; such a driver should NOT supply .bdrv_co_write_zeroes
nor .supported_zero_flags. But none of the drivers touched
in this patch want to do that (the act of writing zeroes is
different enough from normal writes to deserve a second
callback).
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-04 01:39:07 +03:00
|
|
|
} else {
|
|
|
|
assert(!bs->supported_zero_flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == -ENOTSUP) {
|
|
|
|
/* Fall back to bounce buffer if write zeroes is unsupported */
|
block: Honor BDRV_REQ_FUA during write_zeroes
The block layer has a couple of cases where it can lose
Force Unit Access semantics when writing a large block of
zeroes, such that the request returns before the zeroes
have been guaranteed to land on underlying media.
SCSI does not support FUA during WRITESAME(10/16); FUA is only
supported if it falls back to WRITE(10/16). But where the
underlying device is new enough to not need a fallback, it
means that any upper layer request with FUA semantics was
silently ignoring BDRV_REQ_FUA.
Conversely, NBD has situations where it can support FUA but not
ZERO_WRITE; when that happens, the generic block layer fallback
to bdrv_driver_pwritev() (or the older bdrv_co_writev() in qemu
2.6) was losing the FUA flag.
The problem of losing flags unrelated to ZERO_WRITE has been
latent in bdrv_co_do_write_zeroes() since commit aa7bfbff, but
back then, it did not matter because there was no FUA flag. It
became observable when commit 93f5e6d8 paved the way for flags
that can impact correctness, when we should have been using
bdrv_co_writev_flags() with modified flags. Compare to commit
9eeb6dd, which got flag manipulation right in
bdrv_co_do_zero_pwritev().
Symptoms: I tested with qemu-io with default writethrough cache
(which is supposed to use FUA semantics on every write), and
targetted an NBD client connected to a server that intentionally
did not advertise NBD_FLAG_SEND_FUA. When doing 'write 0 512',
the NBD client sent two operations (NBD_CMD_WRITE then
NBD_CMD_FLUSH) to get the fallback FUA semantics; but when doing
'write -z 0 512', the NBD client sent only NBD_CMD_WRITE.
The fix is do to a cleanup bdrv_co_flush() at the end of the
operation if any step in the middle relied on a BDS that does
not natively support FUA for that step (note that we don't
need to flush after every operation, if the operation is broken
into chunks based on bounce-buffer sizing). Each BDS gains a
new flag .supported_zero_flags, which parallels the use of
.supported_write_flags but only when accessing a zero write
operation (the flags MUST be different, because of SCSI having
different semantics based on WRITE vs. WRITESAME; and also
because BDRV_REQ_MAY_UNMAP only makes sense on zero writes).
Also fix some documentation to describe -ENOTSUP semantics,
particularly since iscsi depends on those semantics.
Down the road, we may want to add a driver where its
.bdrv_co_pwritev() honors all three of BDRV_REQ_FUA,
BDRV_REQ_ZERO_WRITE, and BDRV_REQ_MAY_UNMAP, and advertise
this via bs->supported_write_flags for blocks opened by that
driver; such a driver should NOT supply .bdrv_co_write_zeroes
nor .supported_zero_flags. But none of the drivers touched
in this patch want to do that (the act of writing zeroes is
different enough from normal writes to deserve a second
callback).
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-04 01:39:07 +03:00
|
|
|
BdrvRequestFlags write_flags = flags & ~BDRV_REQ_ZERO_WRITE;
|
|
|
|
|
|
|
|
if ((flags & BDRV_REQ_FUA) &&
|
|
|
|
!(bs->supported_write_flags & BDRV_REQ_FUA)) {
|
|
|
|
/* No need for bdrv_driver_pwrite() to do a fallback
|
|
|
|
* flush on each chunk; use just one at the end */
|
|
|
|
write_flags &= ~BDRV_REQ_FUA;
|
|
|
|
need_flush = true;
|
|
|
|
}
|
2016-06-24 01:37:19 +03:00
|
|
|
num = MIN(num, max_transfer);
|
2016-06-02 00:10:03 +03:00
|
|
|
iov.iov_len = num;
|
2015-04-28 16:27:52 +03:00
|
|
|
if (iov.iov_base == NULL) {
|
2016-06-02 00:10:03 +03:00
|
|
|
iov.iov_base = qemu_try_blockalign(bs, num);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (iov.iov_base == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2016-06-02 00:10:03 +03:00
|
|
|
memset(iov.iov_base, 0, num);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
|
|
|
|
2016-06-02 00:10:03 +03:00
|
|
|
ret = bdrv_driver_pwritev(bs, offset, num, &qiov, write_flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
/* Keep bounce buffer around if it is big enough for all
|
|
|
|
* all future requests.
|
|
|
|
*/
|
2016-06-24 01:37:19 +03:00
|
|
|
if (num < max_transfer) {
|
2015-04-28 16:27:52 +03:00
|
|
|
qemu_vfree(iov.iov_base);
|
|
|
|
iov.iov_base = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-02 00:10:03 +03:00
|
|
|
offset += num;
|
2017-06-09 13:18:08 +03:00
|
|
|
bytes -= num;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fail:
|
block: Honor BDRV_REQ_FUA during write_zeroes
The block layer has a couple of cases where it can lose
Force Unit Access semantics when writing a large block of
zeroes, such that the request returns before the zeroes
have been guaranteed to land on underlying media.
SCSI does not support FUA during WRITESAME(10/16); FUA is only
supported if it falls back to WRITE(10/16). But where the
underlying device is new enough to not need a fallback, it
means that any upper layer request with FUA semantics was
silently ignoring BDRV_REQ_FUA.
Conversely, NBD has situations where it can support FUA but not
ZERO_WRITE; when that happens, the generic block layer fallback
to bdrv_driver_pwritev() (or the older bdrv_co_writev() in qemu
2.6) was losing the FUA flag.
The problem of losing flags unrelated to ZERO_WRITE has been
latent in bdrv_co_do_write_zeroes() since commit aa7bfbff, but
back then, it did not matter because there was no FUA flag. It
became observable when commit 93f5e6d8 paved the way for flags
that can impact correctness, when we should have been using
bdrv_co_writev_flags() with modified flags. Compare to commit
9eeb6dd, which got flag manipulation right in
bdrv_co_do_zero_pwritev().
Symptoms: I tested with qemu-io with default writethrough cache
(which is supposed to use FUA semantics on every write), and
targetted an NBD client connected to a server that intentionally
did not advertise NBD_FLAG_SEND_FUA. When doing 'write 0 512',
the NBD client sent two operations (NBD_CMD_WRITE then
NBD_CMD_FLUSH) to get the fallback FUA semantics; but when doing
'write -z 0 512', the NBD client sent only NBD_CMD_WRITE.
The fix is do to a cleanup bdrv_co_flush() at the end of the
operation if any step in the middle relied on a BDS that does
not natively support FUA for that step (note that we don't
need to flush after every operation, if the operation is broken
into chunks based on bounce-buffer sizing). Each BDS gains a
new flag .supported_zero_flags, which parallels the use of
.supported_write_flags but only when accessing a zero write
operation (the flags MUST be different, because of SCSI having
different semantics based on WRITE vs. WRITESAME; and also
because BDRV_REQ_MAY_UNMAP only makes sense on zero writes).
Also fix some documentation to describe -ENOTSUP semantics,
particularly since iscsi depends on those semantics.
Down the road, we may want to add a driver where its
.bdrv_co_pwritev() honors all three of BDRV_REQ_FUA,
BDRV_REQ_ZERO_WRITE, and BDRV_REQ_MAY_UNMAP, and advertise
this via bs->supported_write_flags for blocks opened by that
driver; such a driver should NOT supply .bdrv_co_write_zeroes
nor .supported_zero_flags. But none of the drivers touched
in this patch want to do that (the act of writing zeroes is
different enough from normal writes to deserve a second
callback).
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-04 01:39:07 +03:00
|
|
|
if (ret == 0 && need_flush) {
|
|
|
|
ret = bdrv_co_flush(bs);
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
qemu_vfree(iov.iov_base);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
block: Fragment writes to max transfer length
Drivers should be able to rely on the block layer honoring the
max transfer length, rather than needing to return -EINVAL
(iscsi) or manually fragment things (nbd). We already fragment
write zeroes at the block layer; this patch adds the fragmentation
for normal writes, after requests have been aligned (fragmenting
before alignment would lead to multiple unaligned requests, rather
than just the head and tail).
When fragmenting a large request where FUA was requested, but
where we know that FUA is implemented by flushing all requests
rather than the given request, then we can still get by with
only one flush. Note, however, that we need a followup patch
to the raw format driver to avoid a regression in the number of
flushes actually issued.
The return value was previously nebulous on success (sometimes
zero, sometimes the length written); since we never have a short
write, and since fragmenting may store yet another positive
value in 'ret', change the function to always return 0 on success,
matching what we do in bdrv_aligned_preadv().
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 1468607524-19021-4-git-send-email-eblake@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2016-07-15 21:32:01 +03:00
|
|
|
* Forwards an already correctly aligned write request to the BlockDriver,
|
|
|
|
* after possibly fragmenting it.
|
2015-04-28 16:27:52 +03:00
|
|
|
*/
|
2017-02-09 17:58:43 +03:00
|
|
|
static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
|
2015-04-28 16:27:52 +03:00
|
|
|
BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
|
2016-06-24 01:37:05 +03:00
|
|
|
int64_t align, QEMUIOVector *qiov, int flags)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2017-02-09 17:58:43 +03:00
|
|
|
BlockDriverState *bs = child->bs;
|
2015-04-28 16:27:52 +03:00
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
bool waited;
|
|
|
|
int ret;
|
|
|
|
|
2016-06-03 19:42:51 +03:00
|
|
|
int64_t start_sector = offset >> BDRV_SECTOR_BITS;
|
|
|
|
int64_t end_sector = DIV_ROUND_UP(offset + bytes, BDRV_SECTOR_SIZE);
|
block: Fragment writes to max transfer length
Drivers should be able to rely on the block layer honoring the
max transfer length, rather than needing to return -EINVAL
(iscsi) or manually fragment things (nbd). We already fragment
write zeroes at the block layer; this patch adds the fragmentation
for normal writes, after requests have been aligned (fragmenting
before alignment would lead to multiple unaligned requests, rather
than just the head and tail).
When fragmenting a large request where FUA was requested, but
where we know that FUA is implemented by flushing all requests
rather than the given request, then we can still get by with
only one flush. Note, however, that we need a followup patch
to the raw format driver to avoid a regression in the number of
flushes actually issued.
The return value was previously nebulous on success (sometimes
zero, sometimes the length written); since we never have a short
write, and since fragmenting may store yet another positive
value in 'ret', change the function to always return 0 on success,
matching what we do in bdrv_aligned_preadv().
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 1468607524-19021-4-git-send-email-eblake@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2016-07-15 21:32:01 +03:00
|
|
|
uint64_t bytes_remaining = bytes;
|
|
|
|
int max_transfer;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-06-28 15:05:10 +03:00
|
|
|
if (bdrv_has_readonly_bitmaps(bs)) {
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
2016-06-24 01:37:05 +03:00
|
|
|
assert(is_power_of_2(align));
|
|
|
|
assert((offset & (align - 1)) == 0);
|
|
|
|
assert((bytes & (align - 1)) == 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
assert(!qiov || bytes == qiov->size);
|
2016-03-21 17:11:42 +03:00
|
|
|
assert((bs->open_flags & BDRV_O_NO_IO) == 0);
|
2016-06-13 21:56:35 +03:00
|
|
|
assert(!(flags & ~BDRV_REQ_MASK));
|
block: Fragment writes to max transfer length
Drivers should be able to rely on the block layer honoring the
max transfer length, rather than needing to return -EINVAL
(iscsi) or manually fragment things (nbd). We already fragment
write zeroes at the block layer; this patch adds the fragmentation
for normal writes, after requests have been aligned (fragmenting
before alignment would lead to multiple unaligned requests, rather
than just the head and tail).
When fragmenting a large request where FUA was requested, but
where we know that FUA is implemented by flushing all requests
rather than the given request, then we can still get by with
only one flush. Note, however, that we need a followup patch
to the raw format driver to avoid a regression in the number of
flushes actually issued.
The return value was previously nebulous on success (sometimes
zero, sometimes the length written); since we never have a short
write, and since fragmenting may store yet another positive
value in 'ret', change the function to always return 0 on success,
matching what we do in bdrv_aligned_preadv().
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 1468607524-19021-4-git-send-email-eblake@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2016-07-15 21:32:01 +03:00
|
|
|
max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),
|
|
|
|
align);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
waited = wait_serialising_requests(req);
|
|
|
|
assert(!waited || !req->serialising);
|
|
|
|
assert(req->overlap_offset <= offset);
|
|
|
|
assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
|
2017-04-11 18:52:26 +03:00
|
|
|
assert(child->perm & BLK_PERM_WRITE);
|
|
|
|
assert(end_sector <= bs->total_sectors || child->perm & BLK_PERM_RESIZE);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
|
|
|
|
|
|
|
|
if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
|
2016-06-02 00:10:13 +03:00
|
|
|
!(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_pwrite_zeroes &&
|
2015-04-28 16:27:52 +03:00
|
|
|
qemu_iovec_is_zero(qiov)) {
|
|
|
|
flags |= BDRV_REQ_ZERO_WRITE;
|
|
|
|
if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
|
|
|
|
flags |= BDRV_REQ_MAY_UNMAP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
/* Do nothing, write notifier decided to fail this request */
|
|
|
|
} else if (flags & BDRV_REQ_ZERO_WRITE) {
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);
|
2016-06-03 19:42:51 +03:00
|
|
|
ret = bdrv_co_do_pwrite_zeroes(bs, offset, bytes, flags);
|
2016-07-22 11:17:49 +03:00
|
|
|
} else if (flags & BDRV_REQ_WRITE_COMPRESSED) {
|
|
|
|
ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov);
|
block: Fragment writes to max transfer length
Drivers should be able to rely on the block layer honoring the
max transfer length, rather than needing to return -EINVAL
(iscsi) or manually fragment things (nbd). We already fragment
write zeroes at the block layer; this patch adds the fragmentation
for normal writes, after requests have been aligned (fragmenting
before alignment would lead to multiple unaligned requests, rather
than just the head and tail).
When fragmenting a large request where FUA was requested, but
where we know that FUA is implemented by flushing all requests
rather than the given request, then we can still get by with
only one flush. Note, however, that we need a followup patch
to the raw format driver to avoid a regression in the number of
flushes actually issued.
The return value was previously nebulous on success (sometimes
zero, sometimes the length written); since we never have a short
write, and since fragmenting may store yet another positive
value in 'ret', change the function to always return 0 on success,
matching what we do in bdrv_aligned_preadv().
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 1468607524-19021-4-git-send-email-eblake@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2016-07-15 21:32:01 +03:00
|
|
|
} else if (bytes <= max_transfer) {
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV);
|
2016-04-25 13:13:39 +03:00
|
|
|
ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, flags);
|
block: Fragment writes to max transfer length
Drivers should be able to rely on the block layer honoring the
max transfer length, rather than needing to return -EINVAL
(iscsi) or manually fragment things (nbd). We already fragment
write zeroes at the block layer; this patch adds the fragmentation
for normal writes, after requests have been aligned (fragmenting
before alignment would lead to multiple unaligned requests, rather
than just the head and tail).
When fragmenting a large request where FUA was requested, but
where we know that FUA is implemented by flushing all requests
rather than the given request, then we can still get by with
only one flush. Note, however, that we need a followup patch
to the raw format driver to avoid a regression in the number of
flushes actually issued.
The return value was previously nebulous on success (sometimes
zero, sometimes the length written); since we never have a short
write, and since fragmenting may store yet another positive
value in 'ret', change the function to always return 0 on success,
matching what we do in bdrv_aligned_preadv().
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 1468607524-19021-4-git-send-email-eblake@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2016-07-15 21:32:01 +03:00
|
|
|
} else {
|
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV);
|
|
|
|
while (bytes_remaining) {
|
|
|
|
int num = MIN(bytes_remaining, max_transfer);
|
|
|
|
QEMUIOVector local_qiov;
|
|
|
|
int local_flags = flags;
|
|
|
|
|
|
|
|
assert(num);
|
|
|
|
if (num < bytes_remaining && (flags & BDRV_REQ_FUA) &&
|
|
|
|
!(bs->supported_write_flags & BDRV_REQ_FUA)) {
|
|
|
|
/* If FUA is going to be emulated by flush, we only
|
|
|
|
* need to flush on the last iteration */
|
|
|
|
local_flags &= ~BDRV_REQ_FUA;
|
|
|
|
}
|
|
|
|
qemu_iovec_init(&local_qiov, qiov->niov);
|
|
|
|
qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
|
|
|
|
|
|
|
|
ret = bdrv_driver_pwritev(bs, offset + bytes - bytes_remaining,
|
|
|
|
num, &local_qiov, local_flags);
|
|
|
|
qemu_iovec_destroy(&local_qiov);
|
|
|
|
if (ret < 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
bytes_remaining -= num;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_DONE);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-06-05 15:39:01 +03:00
|
|
|
atomic_inc(&bs->write_gen);
|
2016-06-03 19:42:51 +03:00
|
|
|
bdrv_set_dirty(bs, start_sector, end_sector - start_sector);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-06-05 15:39:00 +03:00
|
|
|
stat64_max(&bs->wr_highest_offset, offset + bytes);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
if (ret >= 0) {
|
2016-06-03 19:42:51 +03:00
|
|
|
bs->total_sectors = MAX(bs->total_sectors, end_sector);
|
block: Fragment writes to max transfer length
Drivers should be able to rely on the block layer honoring the
max transfer length, rather than needing to return -EINVAL
(iscsi) or manually fragment things (nbd). We already fragment
write zeroes at the block layer; this patch adds the fragmentation
for normal writes, after requests have been aligned (fragmenting
before alignment would lead to multiple unaligned requests, rather
than just the head and tail).
When fragmenting a large request where FUA was requested, but
where we know that FUA is implemented by flushing all requests
rather than the given request, then we can still get by with
only one flush. Note, however, that we need a followup patch
to the raw format driver to avoid a regression in the number of
flushes actually issued.
The return value was previously nebulous on success (sometimes
zero, sometimes the length written); since we never have a short
write, and since fragmenting may store yet another positive
value in 'ret', change the function to always return 0 on success,
matching what we do in bdrv_aligned_preadv().
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 1468607524-19021-4-git-send-email-eblake@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2016-07-15 21:32:01 +03:00
|
|
|
ret = 0;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-09 17:58:43 +03:00
|
|
|
static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
|
2015-05-13 16:12:00 +03:00
|
|
|
int64_t offset,
|
|
|
|
unsigned int bytes,
|
|
|
|
BdrvRequestFlags flags,
|
|
|
|
BdrvTrackedRequest *req)
|
|
|
|
{
|
2017-02-09 17:58:43 +03:00
|
|
|
BlockDriverState *bs = child->bs;
|
2015-05-13 16:12:00 +03:00
|
|
|
uint8_t *buf = NULL;
|
|
|
|
QEMUIOVector local_qiov;
|
|
|
|
struct iovec iov;
|
2016-06-24 01:37:24 +03:00
|
|
|
uint64_t align = bs->bl.request_alignment;
|
2015-05-13 16:12:00 +03:00
|
|
|
unsigned int head_padding_bytes, tail_padding_bytes;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
head_padding_bytes = offset & (align - 1);
|
2017-04-26 11:40:46 +03:00
|
|
|
tail_padding_bytes = (align - (offset + bytes)) & (align - 1);
|
2015-05-13 16:12:00 +03:00
|
|
|
|
|
|
|
|
|
|
|
assert(flags & BDRV_REQ_ZERO_WRITE);
|
|
|
|
if (head_padding_bytes || tail_padding_bytes) {
|
|
|
|
buf = qemu_blockalign(bs, align);
|
|
|
|
iov = (struct iovec) {
|
|
|
|
.iov_base = buf,
|
|
|
|
.iov_len = align,
|
|
|
|
};
|
|
|
|
qemu_iovec_init_external(&local_qiov, &iov, 1);
|
|
|
|
}
|
|
|
|
if (head_padding_bytes) {
|
|
|
|
uint64_t zero_bytes = MIN(bytes, align - head_padding_bytes);
|
|
|
|
|
|
|
|
/* RMW the unaligned part before head. */
|
|
|
|
mark_request_serialising(req, align);
|
|
|
|
wait_serialising_requests(req);
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_preadv(child, req, offset & ~(align - 1), align,
|
2015-05-13 16:12:00 +03:00
|
|
|
align, &local_qiov, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
|
2015-05-13 16:12:00 +03:00
|
|
|
|
|
|
|
memset(buf + head_padding_bytes, 0, zero_bytes);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_pwritev(child, req, offset & ~(align - 1), align,
|
2016-06-24 01:37:05 +03:00
|
|
|
align, &local_qiov,
|
2015-05-13 16:12:00 +03:00
|
|
|
flags & ~BDRV_REQ_ZERO_WRITE);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
offset += zero_bytes;
|
|
|
|
bytes -= zero_bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(!bytes || (offset & (align - 1)) == 0);
|
|
|
|
if (bytes >= align) {
|
|
|
|
/* Write the aligned part in the middle. */
|
|
|
|
uint64_t aligned_bytes = bytes & ~(align - 1);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_pwritev(child, req, offset, aligned_bytes, align,
|
2015-05-13 16:12:00 +03:00
|
|
|
NULL, flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
bytes -= aligned_bytes;
|
|
|
|
offset += aligned_bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(!bytes || (offset & (align - 1)) == 0);
|
|
|
|
if (bytes) {
|
|
|
|
assert(align == tail_padding_bytes + bytes);
|
|
|
|
/* RMW the unaligned part after tail. */
|
|
|
|
mark_request_serialising(req, align);
|
|
|
|
wait_serialising_requests(req);
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_preadv(child, req, offset, align,
|
2015-05-13 16:12:00 +03:00
|
|
|
align, &local_qiov, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
|
2015-05-13 16:12:00 +03:00
|
|
|
|
|
|
|
memset(buf, 0, bytes);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_pwritev(child, req, offset, align, align,
|
2015-05-13 16:12:00 +03:00
|
|
|
&local_qiov, flags & ~BDRV_REQ_ZERO_WRITE);
|
|
|
|
}
|
|
|
|
fail:
|
|
|
|
qemu_vfree(buf);
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
/*
|
|
|
|
* Handle a write request in coroutine context
|
|
|
|
*/
|
2016-06-20 22:31:46 +03:00
|
|
|
int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
|
2015-04-28 16:27:52 +03:00
|
|
|
int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
|
|
|
|
BdrvRequestFlags flags)
|
|
|
|
{
|
2016-06-20 22:31:46 +03:00
|
|
|
BlockDriverState *bs = child->bs;
|
2015-04-28 16:27:52 +03:00
|
|
|
BdrvTrackedRequest req;
|
2016-06-24 01:37:24 +03:00
|
|
|
uint64_t align = bs->bl.request_alignment;
|
2015-04-28 16:27:52 +03:00
|
|
|
uint8_t *head_buf = NULL;
|
|
|
|
uint8_t *tail_buf = NULL;
|
|
|
|
QEMUIOVector local_qiov;
|
|
|
|
bool use_local_qiov = false;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!bs->drv) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
if (bs->read_only) {
|
2015-05-07 18:45:48 +03:00
|
|
|
return -EPERM;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
2016-01-13 17:56:06 +03:00
|
|
|
assert(!(bs->open_flags & BDRV_O_INACTIVE));
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
ret = bdrv_check_byte_request(bs, offset, bytes);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_inc_in_flight(bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
/*
|
|
|
|
* Align write if necessary by performing a read-modify-write cycle.
|
|
|
|
* Pad qiov with the read parts and be sure to have a tracked request not
|
|
|
|
* only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
|
|
|
|
*/
|
2015-11-09 13:16:46 +03:00
|
|
|
tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_WRITE);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2015-05-13 16:12:00 +03:00
|
|
|
if (!qiov) {
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_co_do_zero_pwritev(child, offset, bytes, flags, &req);
|
2015-05-13 16:12:00 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
if (offset & (align - 1)) {
|
|
|
|
QEMUIOVector head_qiov;
|
|
|
|
struct iovec head_iov;
|
|
|
|
|
|
|
|
mark_request_serialising(&req, align);
|
|
|
|
wait_serialising_requests(&req);
|
|
|
|
|
|
|
|
head_buf = qemu_blockalign(bs, align);
|
|
|
|
head_iov = (struct iovec) {
|
|
|
|
.iov_base = head_buf,
|
|
|
|
.iov_len = align,
|
|
|
|
};
|
|
|
|
qemu_iovec_init_external(&head_qiov, &head_iov, 1);
|
|
|
|
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_preadv(child, &req, offset & ~(align - 1), align,
|
2015-04-28 16:27:52 +03:00
|
|
|
align, &head_qiov, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
qemu_iovec_init(&local_qiov, qiov->niov + 2);
|
|
|
|
qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
|
|
|
|
qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
|
|
|
|
use_local_qiov = true;
|
|
|
|
|
|
|
|
bytes += offset & (align - 1);
|
|
|
|
offset = offset & ~(align - 1);
|
2016-05-30 14:31:13 +03:00
|
|
|
|
|
|
|
/* We have read the tail already if the request is smaller
|
|
|
|
* than one aligned block.
|
|
|
|
*/
|
|
|
|
if (bytes < align) {
|
|
|
|
qemu_iovec_add(&local_qiov, head_buf + bytes, align - bytes);
|
|
|
|
bytes = align;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((offset + bytes) & (align - 1)) {
|
|
|
|
QEMUIOVector tail_qiov;
|
|
|
|
struct iovec tail_iov;
|
|
|
|
size_t tail_bytes;
|
|
|
|
bool waited;
|
|
|
|
|
|
|
|
mark_request_serialising(&req, align);
|
|
|
|
waited = wait_serialising_requests(&req);
|
|
|
|
assert(!waited || !use_local_qiov);
|
|
|
|
|
|
|
|
tail_buf = qemu_blockalign(bs, align);
|
|
|
|
tail_iov = (struct iovec) {
|
|
|
|
.iov_base = tail_buf,
|
|
|
|
.iov_len = align,
|
|
|
|
};
|
|
|
|
qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
|
|
|
|
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_preadv(child, &req, (offset + bytes) & ~(align - 1),
|
|
|
|
align, align, &tail_qiov, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-06-16 15:19:22 +03:00
|
|
|
bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
if (!use_local_qiov) {
|
|
|
|
qemu_iovec_init(&local_qiov, qiov->niov + 1);
|
|
|
|
qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
|
|
|
|
use_local_qiov = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
tail_bytes = (offset + bytes) & (align - 1);
|
|
|
|
qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
|
|
|
|
|
|
|
|
bytes = ROUND_UP(bytes, align);
|
|
|
|
}
|
|
|
|
|
2017-02-09 17:58:43 +03:00
|
|
|
ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,
|
2016-07-22 11:17:49 +03:00
|
|
|
use_local_qiov ? &local_qiov : qiov,
|
|
|
|
flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
fail:
|
|
|
|
|
|
|
|
if (use_local_qiov) {
|
|
|
|
qemu_iovec_destroy(&local_qiov);
|
|
|
|
}
|
|
|
|
qemu_vfree(head_buf);
|
|
|
|
qemu_vfree(tail_buf);
|
2015-05-13 16:12:00 +03:00
|
|
|
out:
|
|
|
|
tracked_request_end(&req);
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_dec_in_flight(bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-30 14:52:34 +03:00
|
|
|
static int coroutine_fn bdrv_co_do_writev(BdrvChild *child,
|
2015-04-28 16:27:52 +03:00
|
|
|
int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
|
|
|
|
BdrvRequestFlags flags)
|
|
|
|
{
|
|
|
|
if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-06-20 22:31:46 +03:00
|
|
|
return bdrv_co_pwritev(child, sector_num << BDRV_SECTOR_BITS,
|
2016-04-25 15:57:23 +03:00
|
|
|
nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-05-24 18:21:22 +03:00
|
|
|
int coroutine_fn bdrv_co_writev(BdrvChild *child, int64_t sector_num,
|
2015-04-28 16:27:52 +03:00
|
|
|
int nb_sectors, QEMUIOVector *qiov)
|
|
|
|
{
|
2016-05-24 18:21:22 +03:00
|
|
|
trace_bdrv_co_writev(child->bs, sector_num, nb_sectors);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-05-30 14:52:34 +03:00
|
|
|
return bdrv_co_do_writev(child, sector_num, nb_sectors, qiov, 0);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-06-20 22:31:46 +03:00
|
|
|
int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,
|
2017-06-09 13:18:08 +03:00
|
|
|
int bytes, BdrvRequestFlags flags)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2017-06-09 13:18:08 +03:00
|
|
|
trace_bdrv_co_pwrite_zeroes(child->bs, offset, bytes, flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-06-20 22:31:46 +03:00
|
|
|
if (!(child->bs->open_flags & BDRV_O_UNMAP)) {
|
2015-04-28 16:27:52 +03:00
|
|
|
flags &= ~BDRV_REQ_MAY_UNMAP;
|
|
|
|
}
|
|
|
|
|
2017-06-09 13:18:08 +03:00
|
|
|
return bdrv_co_pwritev(child, offset, bytes, NULL,
|
2016-06-02 00:10:04 +03:00
|
|
|
BDRV_REQ_ZERO_WRITE | flags);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-09-23 04:45:50 +03:00
|
|
|
/*
|
|
|
|
* Flush ALL BDSes regardless of if they are reachable via a BlkBackend or not.
|
|
|
|
*/
|
|
|
|
int bdrv_flush_all(void)
|
|
|
|
{
|
|
|
|
BdrvNextIterator it;
|
|
|
|
BlockDriverState *bs = NULL;
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
|
|
|
AioContext *aio_context = bdrv_get_aio_context(bs);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
aio_context_acquire(aio_context);
|
|
|
|
ret = bdrv_flush(bs);
|
|
|
|
if (ret < 0 && !result) {
|
|
|
|
result = ret;
|
|
|
|
}
|
|
|
|
aio_context_release(aio_context);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
typedef struct BdrvCoGetBlockStatusData {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
BlockDriverState *base;
|
2016-01-26 06:58:48 +03:00
|
|
|
BlockDriverState **file;
|
2015-04-28 16:27:52 +03:00
|
|
|
int64_t sector_num;
|
|
|
|
int nb_sectors;
|
|
|
|
int *pnum;
|
|
|
|
int64_t ret;
|
|
|
|
bool done;
|
|
|
|
} BdrvCoGetBlockStatusData;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns the allocation status of the specified sectors.
|
|
|
|
* Drivers not implementing the functionality are assumed to not support
|
|
|
|
* backing files, hence all their sectors are reported as allocated.
|
|
|
|
*
|
2017-05-05 05:14:59 +03:00
|
|
|
* If 'sector_num' is beyond the end of the disk image the return value is
|
|
|
|
* BDRV_BLOCK_EOF and 'pnum' is set to 0.
|
2015-04-28 16:27:52 +03:00
|
|
|
*
|
|
|
|
* 'pnum' is set to the number of sectors (including and immediately following
|
|
|
|
* the specified sector) that are known to be in the same
|
|
|
|
* allocated/unallocated state.
|
|
|
|
*
|
|
|
|
* 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
|
2017-05-05 05:14:59 +03:00
|
|
|
* beyond the end of the disk image it will be clamped; if 'pnum' is set to
|
|
|
|
* the end of the image, then the returned value will include BDRV_BLOCK_EOF.
|
2016-01-26 06:58:48 +03:00
|
|
|
*
|
|
|
|
* If returned value is positive and BDRV_BLOCK_OFFSET_VALID bit is set, 'file'
|
|
|
|
* points to the BDS which the sector range is allocated in.
|
2015-04-28 16:27:52 +03:00
|
|
|
*/
|
|
|
|
static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
|
|
|
|
int64_t sector_num,
|
2016-01-26 06:58:48 +03:00
|
|
|
int nb_sectors, int *pnum,
|
|
|
|
BlockDriverState **file)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
int64_t total_sectors;
|
|
|
|
int64_t n;
|
|
|
|
int64_t ret, ret2;
|
|
|
|
|
2017-06-05 23:38:43 +03:00
|
|
|
*file = NULL;
|
2015-04-28 16:27:52 +03:00
|
|
|
total_sectors = bdrv_nb_sectors(bs);
|
|
|
|
if (total_sectors < 0) {
|
|
|
|
return total_sectors;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sector_num >= total_sectors) {
|
|
|
|
*pnum = 0;
|
2017-05-05 05:14:59 +03:00
|
|
|
return BDRV_BLOCK_EOF;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
n = total_sectors - sector_num;
|
|
|
|
if (n < nb_sectors) {
|
|
|
|
nb_sectors = n;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!bs->drv->bdrv_co_get_block_status) {
|
|
|
|
*pnum = nb_sectors;
|
|
|
|
ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
|
2017-05-05 05:14:59 +03:00
|
|
|
if (sector_num + nb_sectors == total_sectors) {
|
|
|
|
ret |= BDRV_BLOCK_EOF;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
if (bs->drv->protocol_name) {
|
|
|
|
ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
|
2017-06-05 23:38:43 +03:00
|
|
|
*file = bs;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_inc_in_flight(bs);
|
2016-01-26 06:58:48 +03:00
|
|
|
ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum,
|
|
|
|
file);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
*pnum = 0;
|
2016-10-27 13:48:52 +03:00
|
|
|
goto out;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret & BDRV_BLOCK_RAW) {
|
2017-06-05 23:38:43 +03:00
|
|
|
assert(ret & BDRV_BLOCK_OFFSET_VALID && *file);
|
2017-05-04 20:37:45 +03:00
|
|
|
ret = bdrv_co_get_block_status(*file, ret >> BDRV_SECTOR_BITS,
|
|
|
|
*pnum, pnum, file);
|
2016-10-27 13:48:52 +03:00
|
|
|
goto out;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
|
|
|
|
ret |= BDRV_BLOCK_ALLOCATED;
|
2015-05-14 13:35:02 +03:00
|
|
|
} else {
|
2015-04-28 16:27:52 +03:00
|
|
|
if (bdrv_unallocated_blocks_are_zero(bs)) {
|
|
|
|
ret |= BDRV_BLOCK_ZERO;
|
2015-06-17 15:55:21 +03:00
|
|
|
} else if (bs->backing) {
|
|
|
|
BlockDriverState *bs2 = bs->backing->bs;
|
2015-04-28 16:27:52 +03:00
|
|
|
int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
|
|
|
|
if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
|
|
|
|
ret |= BDRV_BLOCK_ZERO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-26 06:59:00 +03:00
|
|
|
if (*file && *file != bs &&
|
2015-04-28 16:27:52 +03:00
|
|
|
(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
|
|
|
|
(ret & BDRV_BLOCK_OFFSET_VALID)) {
|
2016-01-26 06:58:48 +03:00
|
|
|
BlockDriverState *file2;
|
2015-04-28 16:27:52 +03:00
|
|
|
int file_pnum;
|
|
|
|
|
2016-01-26 06:59:00 +03:00
|
|
|
ret2 = bdrv_co_get_block_status(*file, ret >> BDRV_SECTOR_BITS,
|
2016-01-26 06:58:48 +03:00
|
|
|
*pnum, &file_pnum, &file2);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret2 >= 0) {
|
|
|
|
/* Ignore errors. This is just providing extra information, it
|
|
|
|
* is useful but not necessary.
|
|
|
|
*/
|
block: Exploit BDRV_BLOCK_EOF for larger zero blocks
When we have a BDS with unallocated clusters, but asking the status
of its underlying bs->file or backing layer encounters an end-of-file
condition, we know that the rest of the unallocated area will read as
zeroes. However, pre-patch, this required two separate calls to
bdrv_get_block_status(), as the first call stops at the point where
the underlying file ends. Thanks to BDRV_BLOCK_EOF, we can now widen
the results of the primary status if the secondary status already
includes BDRV_BLOCK_ZERO.
In turn, this fixes a TODO mentioned in iotest 154, where we can now
see that all sectors in a partial cluster at the end of a file read
as zero when coupling the shorter backing file's status along with our
knowledge that the remaining sectors came from an unallocated cluster.
Also, note that the loop in bdrv_co_get_block_status_above() had an
inefficent exit: in cases where the active layer sets BDRV_BLOCK_ZERO
but does NOT set BDRV_BLOCK_ALLOCATED (namely, where we know we read
zeroes merely because our unallocated clusters lie beyond the backing
file's shorter length), we still ended up probing the backing layer
even though we already had a good answer.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20170505021500.19315-3-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
2017-05-05 05:15:00 +03:00
|
|
|
if (ret2 & BDRV_BLOCK_EOF &&
|
|
|
|
(!file_pnum || ret2 & BDRV_BLOCK_ZERO)) {
|
|
|
|
/*
|
|
|
|
* It is valid for the format block driver to read
|
|
|
|
* beyond the end of the underlying file's current
|
|
|
|
* size; such areas read as zero.
|
|
|
|
*/
|
2015-04-28 16:27:52 +03:00
|
|
|
ret |= BDRV_BLOCK_ZERO;
|
|
|
|
} else {
|
|
|
|
/* Limit request to the range reported by the protocol driver */
|
|
|
|
*pnum = file_pnum;
|
|
|
|
ret |= (ret2 & BDRV_BLOCK_ZERO);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
out:
|
|
|
|
bdrv_dec_in_flight(bs);
|
2017-05-05 05:14:59 +03:00
|
|
|
if (ret >= 0 && sector_num + *pnum == total_sectors) {
|
|
|
|
ret |= BDRV_BLOCK_EOF;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-06-08 08:56:07 +03:00
|
|
|
static int64_t coroutine_fn bdrv_co_get_block_status_above(BlockDriverState *bs,
|
|
|
|
BlockDriverState *base,
|
|
|
|
int64_t sector_num,
|
|
|
|
int nb_sectors,
|
2016-01-26 06:58:48 +03:00
|
|
|
int *pnum,
|
|
|
|
BlockDriverState **file)
|
2015-06-08 08:56:07 +03:00
|
|
|
{
|
|
|
|
BlockDriverState *p;
|
|
|
|
int64_t ret = 0;
|
block: Exploit BDRV_BLOCK_EOF for larger zero blocks
When we have a BDS with unallocated clusters, but asking the status
of its underlying bs->file or backing layer encounters an end-of-file
condition, we know that the rest of the unallocated area will read as
zeroes. However, pre-patch, this required two separate calls to
bdrv_get_block_status(), as the first call stops at the point where
the underlying file ends. Thanks to BDRV_BLOCK_EOF, we can now widen
the results of the primary status if the secondary status already
includes BDRV_BLOCK_ZERO.
In turn, this fixes a TODO mentioned in iotest 154, where we can now
see that all sectors in a partial cluster at the end of a file read
as zero when coupling the shorter backing file's status along with our
knowledge that the remaining sectors came from an unallocated cluster.
Also, note that the loop in bdrv_co_get_block_status_above() had an
inefficent exit: in cases where the active layer sets BDRV_BLOCK_ZERO
but does NOT set BDRV_BLOCK_ALLOCATED (namely, where we know we read
zeroes merely because our unallocated clusters lie beyond the backing
file's shorter length), we still ended up probing the backing layer
even though we already had a good answer.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20170505021500.19315-3-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
2017-05-05 05:15:00 +03:00
|
|
|
bool first = true;
|
2015-06-08 08:56:07 +03:00
|
|
|
|
|
|
|
assert(bs != base);
|
2015-06-17 15:55:21 +03:00
|
|
|
for (p = bs; p != base; p = backing_bs(p)) {
|
2016-01-26 06:58:48 +03:00
|
|
|
ret = bdrv_co_get_block_status(p, sector_num, nb_sectors, pnum, file);
|
block: Exploit BDRV_BLOCK_EOF for larger zero blocks
When we have a BDS with unallocated clusters, but asking the status
of its underlying bs->file or backing layer encounters an end-of-file
condition, we know that the rest of the unallocated area will read as
zeroes. However, pre-patch, this required two separate calls to
bdrv_get_block_status(), as the first call stops at the point where
the underlying file ends. Thanks to BDRV_BLOCK_EOF, we can now widen
the results of the primary status if the secondary status already
includes BDRV_BLOCK_ZERO.
In turn, this fixes a TODO mentioned in iotest 154, where we can now
see that all sectors in a partial cluster at the end of a file read
as zero when coupling the shorter backing file's status along with our
knowledge that the remaining sectors came from an unallocated cluster.
Also, note that the loop in bdrv_co_get_block_status_above() had an
inefficent exit: in cases where the active layer sets BDRV_BLOCK_ZERO
but does NOT set BDRV_BLOCK_ALLOCATED (namely, where we know we read
zeroes merely because our unallocated clusters lie beyond the backing
file's shorter length), we still ended up probing the backing layer
even though we already had a good answer.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20170505021500.19315-3-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
2017-05-05 05:15:00 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ret & BDRV_BLOCK_ZERO && ret & BDRV_BLOCK_EOF && !first) {
|
|
|
|
/*
|
|
|
|
* Reading beyond the end of the file continues to read
|
|
|
|
* zeroes, but we can only widen the result to the
|
|
|
|
* unallocated length we learned from an earlier
|
|
|
|
* iteration.
|
|
|
|
*/
|
|
|
|
*pnum = nb_sectors;
|
|
|
|
}
|
|
|
|
if (ret & (BDRV_BLOCK_ZERO | BDRV_BLOCK_DATA)) {
|
2015-06-08 08:56:07 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* [sector_num, pnum] unallocated on this layer, which could be only
|
|
|
|
* the first part of [sector_num, nb_sectors]. */
|
|
|
|
nb_sectors = MIN(nb_sectors, *pnum);
|
block: Exploit BDRV_BLOCK_EOF for larger zero blocks
When we have a BDS with unallocated clusters, but asking the status
of its underlying bs->file or backing layer encounters an end-of-file
condition, we know that the rest of the unallocated area will read as
zeroes. However, pre-patch, this required two separate calls to
bdrv_get_block_status(), as the first call stops at the point where
the underlying file ends. Thanks to BDRV_BLOCK_EOF, we can now widen
the results of the primary status if the secondary status already
includes BDRV_BLOCK_ZERO.
In turn, this fixes a TODO mentioned in iotest 154, where we can now
see that all sectors in a partial cluster at the end of a file read
as zero when coupling the shorter backing file's status along with our
knowledge that the remaining sectors came from an unallocated cluster.
Also, note that the loop in bdrv_co_get_block_status_above() had an
inefficent exit: in cases where the active layer sets BDRV_BLOCK_ZERO
but does NOT set BDRV_BLOCK_ALLOCATED (namely, where we know we read
zeroes merely because our unallocated clusters lie beyond the backing
file's shorter length), we still ended up probing the backing layer
even though we already had a good answer.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20170505021500.19315-3-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
2017-05-05 05:15:00 +03:00
|
|
|
first = false;
|
2015-06-08 08:56:07 +03:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Coroutine wrapper for bdrv_get_block_status_above() */
|
|
|
|
static void coroutine_fn bdrv_get_block_status_above_co_entry(void *opaque)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
BdrvCoGetBlockStatusData *data = opaque;
|
|
|
|
|
2015-06-08 08:56:07 +03:00
|
|
|
data->ret = bdrv_co_get_block_status_above(data->bs, data->base,
|
|
|
|
data->sector_num,
|
|
|
|
data->nb_sectors,
|
2016-01-26 06:58:48 +03:00
|
|
|
data->pnum,
|
|
|
|
data->file);
|
2015-04-28 16:27:52 +03:00
|
|
|
data->done = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-06-08 08:56:07 +03:00
|
|
|
* Synchronous wrapper around bdrv_co_get_block_status_above().
|
2015-04-28 16:27:52 +03:00
|
|
|
*
|
2015-06-08 08:56:07 +03:00
|
|
|
* See bdrv_co_get_block_status_above() for details.
|
2015-04-28 16:27:52 +03:00
|
|
|
*/
|
2015-06-08 08:56:07 +03:00
|
|
|
int64_t bdrv_get_block_status_above(BlockDriverState *bs,
|
|
|
|
BlockDriverState *base,
|
|
|
|
int64_t sector_num,
|
2016-01-26 06:58:48 +03:00
|
|
|
int nb_sectors, int *pnum,
|
|
|
|
BlockDriverState **file)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
Coroutine *co;
|
|
|
|
BdrvCoGetBlockStatusData data = {
|
|
|
|
.bs = bs,
|
2015-06-08 08:56:07 +03:00
|
|
|
.base = base,
|
2016-01-26 06:58:48 +03:00
|
|
|
.file = file,
|
2015-04-28 16:27:52 +03:00
|
|
|
.sector_num = sector_num,
|
|
|
|
.nb_sectors = nb_sectors,
|
|
|
|
.pnum = pnum,
|
|
|
|
.done = false,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
/* Fast-path if already in coroutine context */
|
2015-06-08 08:56:07 +03:00
|
|
|
bdrv_get_block_status_above_co_entry(&data);
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 20:10:01 +03:00
|
|
|
co = qemu_coroutine_create(bdrv_get_block_status_above_co_entry,
|
|
|
|
&data);
|
block: Use bdrv_coroutine_enter to start I/O coroutines
BDRV_POLL_WHILE waits for the started I/O by releasing bs's ctx then polling
the main context, which relies on the yielded coroutine continuing on bs->ctx
before notifying qemu_aio_context with bdrv_wakeup().
Thus, using qemu_coroutine_enter to start I/O is wrong because if the coroutine
is entered from main loop, co->ctx will be qemu_aio_context, as a result of the
"release, poll, acquire" loop of BDRV_POLL_WHILE, race conditions happen when
both main thread and the iothread access the same BDS:
main loop iothread
-----------------------------------------------------------------------
blockdev_snapshot
aio_context_acquire(bs->ctx)
virtio_scsi_data_plane_handle_cmd
bdrv_drained_begin(bs->ctx)
bdrv_flush(bs)
bdrv_co_flush(bs) aio_context_acquire(bs->ctx).enter
...
qemu_coroutine_yield(co)
BDRV_POLL_WHILE()
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx).return
...
aio_co_wake(co)
aio_poll(qemu_aio_context) ...
co_schedule_bh_cb() ...
qemu_coroutine_enter(co) ...
/* (A) bdrv_co_flush(bs) /* (B) I/O on bs */
continues... */
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx)
Note that in above case, bdrv_drained_begin() doesn't do the "release,
poll, acquire" in BDRV_POLL_WHILE, because bs->in_flight == 0.
Fix this by using bdrv_coroutine_enter and enter coroutine in the right
context.
iotests 109 output is updated because the coroutine reenter flow during
mirror job complete is different (now through co_queue_wakeup, instead
of the unconditional qemu_coroutine_switch before), making the end job
len different.
Signed-off-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
2017-04-10 15:20:17 +03:00
|
|
|
bdrv_coroutine_enter(bs, co);
|
2016-10-27 13:48:55 +03:00
|
|
|
BDRV_POLL_WHILE(bs, !data.done);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
return data.ret;
|
|
|
|
}
|
|
|
|
|
2015-06-08 08:56:07 +03:00
|
|
|
int64_t bdrv_get_block_status(BlockDriverState *bs,
|
|
|
|
int64_t sector_num,
|
2016-01-26 06:58:48 +03:00
|
|
|
int nb_sectors, int *pnum,
|
|
|
|
BlockDriverState **file)
|
2015-06-08 08:56:07 +03:00
|
|
|
{
|
2015-06-17 15:55:21 +03:00
|
|
|
return bdrv_get_block_status_above(bs, backing_bs(bs),
|
2016-01-26 06:58:48 +03:00
|
|
|
sector_num, nb_sectors, pnum, file);
|
2015-06-08 08:56:07 +03:00
|
|
|
}
|
|
|
|
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
|
|
|
|
int64_t bytes, int64_t *pnum)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2016-01-26 06:58:48 +03:00
|
|
|
BlockDriverState *file;
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
int64_t sector_num = offset >> BDRV_SECTOR_BITS;
|
|
|
|
int nb_sectors = bytes >> BDRV_SECTOR_BITS;
|
|
|
|
int64_t ret;
|
|
|
|
int psectors;
|
|
|
|
|
|
|
|
assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));
|
|
|
|
assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE) && bytes < INT_MAX);
|
|
|
|
ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &psectors,
|
|
|
|
&file);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
if (pnum) {
|
|
|
|
*pnum = psectors * BDRV_SECTOR_SIZE;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
return !!(ret & BDRV_BLOCK_ALLOCATED);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
|
|
|
|
*
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
* Return true if (a prefix of) the given range is allocated in any image
|
|
|
|
* between BASE and TOP (inclusive). BASE can be NULL to check if the given
|
|
|
|
* offset is allocated in any image of the chain. Return false otherwise,
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
* or negative errno on failure.
|
2015-04-28 16:27:52 +03:00
|
|
|
*
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
* 'pnum' is set to the number of bytes (including and immediately
|
|
|
|
* following the specified offset) that are known to be in the same
|
|
|
|
* allocated/unallocated state. Note that a subsequent call starting
|
|
|
|
* at 'offset + *pnum' may return the same allocation status (in other
|
|
|
|
* words, the result is not necessarily the maximum possible range);
|
|
|
|
* but 'pnum' will only be 0 when end of file is reached.
|
2015-04-28 16:27:52 +03:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
int bdrv_is_allocated_above(BlockDriverState *top,
|
|
|
|
BlockDriverState *base,
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
int64_t offset, int64_t bytes, int64_t *pnum)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
BlockDriverState *intermediate;
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
int ret;
|
|
|
|
int64_t n = bytes;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
intermediate = top;
|
|
|
|
while (intermediate && intermediate != base) {
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
int64_t pnum_inter;
|
2017-07-07 15:44:58 +03:00
|
|
|
int64_t size_inter;
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
ret = bdrv_is_allocated(intermediate, offset, bytes, &pnum_inter);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
}
|
|
|
|
if (ret) {
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
*pnum = pnum_inter;
|
2015-04-28 16:27:52 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
size_inter = bdrv_getlength(intermediate);
|
2017-07-07 15:44:58 +03:00
|
|
|
if (size_inter < 0) {
|
|
|
|
return size_inter;
|
|
|
|
}
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:59 +03:00
|
|
|
if (n > pnum_inter &&
|
|
|
|
(intermediate == top || offset + pnum_inter < size_inter)) {
|
|
|
|
n = pnum_inter;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2015-06-17 15:55:21 +03:00
|
|
|
intermediate = backing_bs(intermediate);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
*pnum = n;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-09 17:24:44 +03:00
|
|
|
typedef struct BdrvVmstateCo {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
QEMUIOVector *qiov;
|
|
|
|
int64_t pos;
|
|
|
|
bool is_read;
|
|
|
|
int ret;
|
|
|
|
} BdrvVmstateCo;
|
|
|
|
|
|
|
|
static int coroutine_fn
|
|
|
|
bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
|
|
|
|
bool is_read)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
2017-05-22 16:57:01 +03:00
|
|
|
int ret = -ENOTSUP;
|
|
|
|
|
|
|
|
bdrv_inc_in_flight(bs);
|
2016-06-09 17:24:44 +03:00
|
|
|
|
|
|
|
if (!drv) {
|
2017-05-22 16:57:01 +03:00
|
|
|
ret = -ENOMEDIUM;
|
2016-06-09 17:24:44 +03:00
|
|
|
} else if (drv->bdrv_load_vmstate) {
|
2017-05-22 16:57:01 +03:00
|
|
|
if (is_read) {
|
|
|
|
ret = drv->bdrv_load_vmstate(bs, qiov, pos);
|
|
|
|
} else {
|
|
|
|
ret = drv->bdrv_save_vmstate(bs, qiov, pos);
|
|
|
|
}
|
2016-06-09 17:24:44 +03:00
|
|
|
} else if (bs->file) {
|
2017-05-22 16:57:01 +03:00
|
|
|
ret = bdrv_co_rw_vmstate(bs->file->bs, qiov, pos, is_read);
|
2016-06-09 17:24:44 +03:00
|
|
|
}
|
|
|
|
|
2017-05-22 16:57:01 +03:00
|
|
|
bdrv_dec_in_flight(bs);
|
|
|
|
return ret;
|
2016-06-09 17:24:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void coroutine_fn bdrv_co_rw_vmstate_entry(void *opaque)
|
|
|
|
{
|
|
|
|
BdrvVmstateCo *co = opaque;
|
|
|
|
co->ret = bdrv_co_rw_vmstate(co->bs, co->qiov, co->pos, co->is_read);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
|
|
|
|
bool is_read)
|
|
|
|
{
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
return bdrv_co_rw_vmstate(bs, qiov, pos, is_read);
|
|
|
|
} else {
|
|
|
|
BdrvVmstateCo data = {
|
|
|
|
.bs = bs,
|
|
|
|
.qiov = qiov,
|
|
|
|
.pos = pos,
|
|
|
|
.is_read = is_read,
|
|
|
|
.ret = -EINPROGRESS,
|
|
|
|
};
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 20:10:01 +03:00
|
|
|
Coroutine *co = qemu_coroutine_create(bdrv_co_rw_vmstate_entry, &data);
|
2016-06-09 17:24:44 +03:00
|
|
|
|
block: Use bdrv_coroutine_enter to start I/O coroutines
BDRV_POLL_WHILE waits for the started I/O by releasing bs's ctx then polling
the main context, which relies on the yielded coroutine continuing on bs->ctx
before notifying qemu_aio_context with bdrv_wakeup().
Thus, using qemu_coroutine_enter to start I/O is wrong because if the coroutine
is entered from main loop, co->ctx will be qemu_aio_context, as a result of the
"release, poll, acquire" loop of BDRV_POLL_WHILE, race conditions happen when
both main thread and the iothread access the same BDS:
main loop iothread
-----------------------------------------------------------------------
blockdev_snapshot
aio_context_acquire(bs->ctx)
virtio_scsi_data_plane_handle_cmd
bdrv_drained_begin(bs->ctx)
bdrv_flush(bs)
bdrv_co_flush(bs) aio_context_acquire(bs->ctx).enter
...
qemu_coroutine_yield(co)
BDRV_POLL_WHILE()
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx).return
...
aio_co_wake(co)
aio_poll(qemu_aio_context) ...
co_schedule_bh_cb() ...
qemu_coroutine_enter(co) ...
/* (A) bdrv_co_flush(bs) /* (B) I/O on bs */
continues... */
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx)
Note that in above case, bdrv_drained_begin() doesn't do the "release,
poll, acquire" in BDRV_POLL_WHILE, because bs->in_flight == 0.
Fix this by using bdrv_coroutine_enter and enter coroutine in the right
context.
iotests 109 output is updated because the coroutine reenter flow during
mirror job complete is different (now through co_queue_wakeup, instead
of the unconditional qemu_coroutine_switch before), making the end job
len different.
Signed-off-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
2017-04-10 15:20:17 +03:00
|
|
|
bdrv_coroutine_enter(bs, co);
|
2017-05-22 16:57:02 +03:00
|
|
|
BDRV_POLL_WHILE(bs, data.ret == -EINPROGRESS);
|
2016-06-09 17:24:44 +03:00
|
|
|
return data.ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
|
|
|
|
int64_t pos, int size)
|
|
|
|
{
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_base = (void *) buf,
|
|
|
|
.iov_len = size,
|
|
|
|
};
|
2016-06-10 18:57:26 +03:00
|
|
|
int ret;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
2016-06-10 18:57:26 +03:00
|
|
|
|
|
|
|
ret = bdrv_writev_vmstate(bs, &qiov, pos);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
|
|
|
|
{
|
2016-06-09 17:24:44 +03:00
|
|
|
return bdrv_rw_vmstate(bs, qiov, pos, false);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
|
|
|
|
int64_t pos, int size)
|
2016-06-09 17:50:16 +03:00
|
|
|
{
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_base = buf,
|
|
|
|
.iov_len = size,
|
|
|
|
};
|
2016-06-10 18:57:26 +03:00
|
|
|
int ret;
|
2016-06-09 17:50:16 +03:00
|
|
|
|
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
2016-06-10 18:57:26 +03:00
|
|
|
ret = bdrv_readv_vmstate(bs, &qiov, pos);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
2016-06-09 17:50:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2016-06-09 17:24:44 +03:00
|
|
|
return bdrv_rw_vmstate(bs, qiov, pos, true);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
/* async I/Os */
|
|
|
|
|
|
|
|
void bdrv_aio_cancel(BlockAIOCB *acb)
|
|
|
|
{
|
|
|
|
qemu_aio_ref(acb);
|
|
|
|
bdrv_aio_cancel_async(acb);
|
|
|
|
while (acb->refcnt > 1) {
|
|
|
|
if (acb->aiocb_info->get_aio_context) {
|
|
|
|
aio_poll(acb->aiocb_info->get_aio_context(acb), true);
|
|
|
|
} else if (acb->bs) {
|
2017-02-13 16:52:29 +03:00
|
|
|
/* qemu_aio_ref and qemu_aio_unref are not thread-safe, so
|
|
|
|
* assert that we're not using an I/O thread. Thread-safe
|
|
|
|
* code should use bdrv_aio_cancel_async exclusively.
|
|
|
|
*/
|
|
|
|
assert(bdrv_get_aio_context(acb->bs) == qemu_get_aio_context());
|
2015-04-28 16:27:52 +03:00
|
|
|
aio_poll(bdrv_get_aio_context(acb->bs), true);
|
|
|
|
} else {
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qemu_aio_unref(acb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Async version of aio cancel. The caller is not blocked if the acb implements
|
|
|
|
* cancel_async, otherwise we do nothing and let the request normally complete.
|
|
|
|
* In either case the completion callback must be called. */
|
|
|
|
void bdrv_aio_cancel_async(BlockAIOCB *acb)
|
|
|
|
{
|
|
|
|
if (acb->aiocb_info->cancel_async) {
|
|
|
|
acb->aiocb_info->cancel_async(acb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
/* Coroutine block device emulation */
|
|
|
|
|
2016-05-30 16:00:40 +03:00
|
|
|
typedef struct FlushCo {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
int ret;
|
|
|
|
} FlushCo;
|
|
|
|
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
static void coroutine_fn bdrv_flush_co_entry(void *opaque)
|
|
|
|
{
|
2016-05-30 16:00:40 +03:00
|
|
|
FlushCo *rwco = opaque;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
rwco->ret = bdrv_co_flush(rwco->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
|
|
|
|
{
|
2017-04-10 16:00:50 +03:00
|
|
|
int current_gen;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
bdrv_inc_in_flight(bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-04-26 05:03:49 +03:00
|
|
|
if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs) ||
|
2015-06-23 13:44:57 +03:00
|
|
|
bdrv_is_sg(bs)) {
|
2017-04-10 16:00:50 +03:00
|
|
|
goto early_exit;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_lock(&bs->reqs_lock);
|
2017-06-05 15:39:01 +03:00
|
|
|
current_gen = atomic_read(&bs->write_gen);
|
2016-07-18 22:39:52 +03:00
|
|
|
|
|
|
|
/* Wait until any previous flushes are completed */
|
2016-10-27 13:48:52 +03:00
|
|
|
while (bs->active_flush_req) {
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_queue_wait(&bs->flush_queue, &bs->reqs_lock);
|
2016-07-18 22:39:52 +03:00
|
|
|
}
|
|
|
|
|
2017-06-05 15:39:02 +03:00
|
|
|
/* Flushes reach this point in nondecreasing current_gen order. */
|
2016-10-27 13:48:52 +03:00
|
|
|
bs->active_flush_req = true;
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_unlock(&bs->reqs_lock);
|
2016-07-18 22:39:52 +03:00
|
|
|
|
2016-03-14 10:44:53 +03:00
|
|
|
/* Write back all layers by calling one driver function */
|
|
|
|
if (bs->drv->bdrv_co_flush) {
|
|
|
|
ret = bs->drv->bdrv_co_flush(bs);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
/* Write back cached data to the OS even with cache=unsafe */
|
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
|
|
|
|
if (bs->drv->bdrv_co_flush_to_os) {
|
|
|
|
ret = bs->drv->bdrv_co_flush_to_os(bs);
|
|
|
|
if (ret < 0) {
|
2015-11-09 13:16:47 +03:00
|
|
|
goto out;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* But don't actually force it to the disk with cache=unsafe */
|
|
|
|
if (bs->open_flags & BDRV_O_NO_FLUSH) {
|
|
|
|
goto flush_parent;
|
|
|
|
}
|
|
|
|
|
2016-07-18 22:39:52 +03:00
|
|
|
/* Check if we really need to flush anything */
|
|
|
|
if (bs->flushed_gen == current_gen) {
|
|
|
|
goto flush_parent;
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
|
|
|
|
if (bs->drv->bdrv_co_flush_to_disk) {
|
|
|
|
ret = bs->drv->bdrv_co_flush_to_disk(bs);
|
|
|
|
} else if (bs->drv->bdrv_aio_flush) {
|
|
|
|
BlockAIOCB *acb;
|
|
|
|
CoroutineIOCompletion co = {
|
|
|
|
.coroutine = qemu_coroutine_self(),
|
|
|
|
};
|
|
|
|
|
|
|
|
acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
|
|
|
|
if (acb == NULL) {
|
|
|
|
ret = -EIO;
|
|
|
|
} else {
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
ret = co.ret;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Some block drivers always operate in either writethrough or unsafe
|
|
|
|
* mode and don't support bdrv_flush therefore. Usually qemu doesn't
|
|
|
|
* know how the server works (because the behaviour is hardcoded or
|
|
|
|
* depends on server-side configuration), so we can't ensure that
|
|
|
|
* everything is safe on disk. Returning an error doesn't work because
|
|
|
|
* that would break guests even if the server operates in writethrough
|
|
|
|
* mode.
|
|
|
|
*
|
|
|
|
* Let's hope the user knows what he's doing.
|
|
|
|
*/
|
|
|
|
ret = 0;
|
|
|
|
}
|
2016-07-18 22:39:52 +03:00
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
2015-11-09 13:16:47 +03:00
|
|
|
goto out;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
|
|
|
|
* in the case of cache=unsafe, so there are no useless flushes.
|
|
|
|
*/
|
|
|
|
flush_parent:
|
2015-11-09 13:16:47 +03:00
|
|
|
ret = bs->file ? bdrv_co_flush(bs->file->bs) : 0;
|
|
|
|
out:
|
2016-07-18 22:39:52 +03:00
|
|
|
/* Notify any pending flushes that we have completed */
|
2016-11-05 02:03:15 +03:00
|
|
|
if (ret == 0) {
|
|
|
|
bs->flushed_gen = current_gen;
|
|
|
|
}
|
2017-06-05 15:39:02 +03:00
|
|
|
|
|
|
|
qemu_co_mutex_lock(&bs->reqs_lock);
|
2016-10-27 13:48:52 +03:00
|
|
|
bs->active_flush_req = false;
|
2016-08-17 21:06:54 +03:00
|
|
|
/* Return value is ignored - it's ok if wait queue is empty */
|
|
|
|
qemu_co_queue_next(&bs->flush_queue);
|
2017-06-05 15:39:02 +03:00
|
|
|
qemu_co_mutex_unlock(&bs->reqs_lock);
|
2016-07-18 22:39:52 +03:00
|
|
|
|
2017-04-10 16:00:50 +03:00
|
|
|
early_exit:
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_dec_in_flight(bs);
|
2015-11-09 13:16:47 +03:00
|
|
|
return ret;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int bdrv_flush(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
Coroutine *co;
|
2016-05-30 16:00:40 +03:00
|
|
|
FlushCo flush_co = {
|
2015-04-28 16:27:52 +03:00
|
|
|
.bs = bs,
|
|
|
|
.ret = NOT_DONE,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
/* Fast-path if already in coroutine context */
|
2016-05-30 16:00:40 +03:00
|
|
|
bdrv_flush_co_entry(&flush_co);
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 20:10:01 +03:00
|
|
|
co = qemu_coroutine_create(bdrv_flush_co_entry, &flush_co);
|
block: Use bdrv_coroutine_enter to start I/O coroutines
BDRV_POLL_WHILE waits for the started I/O by releasing bs's ctx then polling
the main context, which relies on the yielded coroutine continuing on bs->ctx
before notifying qemu_aio_context with bdrv_wakeup().
Thus, using qemu_coroutine_enter to start I/O is wrong because if the coroutine
is entered from main loop, co->ctx will be qemu_aio_context, as a result of the
"release, poll, acquire" loop of BDRV_POLL_WHILE, race conditions happen when
both main thread and the iothread access the same BDS:
main loop iothread
-----------------------------------------------------------------------
blockdev_snapshot
aio_context_acquire(bs->ctx)
virtio_scsi_data_plane_handle_cmd
bdrv_drained_begin(bs->ctx)
bdrv_flush(bs)
bdrv_co_flush(bs) aio_context_acquire(bs->ctx).enter
...
qemu_coroutine_yield(co)
BDRV_POLL_WHILE()
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx).return
...
aio_co_wake(co)
aio_poll(qemu_aio_context) ...
co_schedule_bh_cb() ...
qemu_coroutine_enter(co) ...
/* (A) bdrv_co_flush(bs) /* (B) I/O on bs */
continues... */
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx)
Note that in above case, bdrv_drained_begin() doesn't do the "release,
poll, acquire" in BDRV_POLL_WHILE, because bs->in_flight == 0.
Fix this by using bdrv_coroutine_enter and enter coroutine in the right
context.
iotests 109 output is updated because the coroutine reenter flow during
mirror job complete is different (now through co_queue_wakeup, instead
of the unconditional qemu_coroutine_switch before), making the end job
len different.
Signed-off-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
2017-04-10 15:20:17 +03:00
|
|
|
bdrv_coroutine_enter(bs, co);
|
2016-10-27 13:48:55 +03:00
|
|
|
BDRV_POLL_WHILE(bs, flush_co.ret == NOT_DONE);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-05-30 16:00:40 +03:00
|
|
|
return flush_co.ret;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct DiscardCo {
|
|
|
|
BlockDriverState *bs;
|
2016-07-16 02:22:51 +03:00
|
|
|
int64_t offset;
|
2017-06-09 13:18:08 +03:00
|
|
|
int bytes;
|
2015-04-28 16:27:52 +03:00
|
|
|
int ret;
|
|
|
|
} DiscardCo;
|
2016-07-16 02:22:51 +03:00
|
|
|
static void coroutine_fn bdrv_pdiscard_co_entry(void *opaque)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
DiscardCo *rwco = opaque;
|
|
|
|
|
2017-06-09 13:18:08 +03:00
|
|
|
rwco->ret = bdrv_co_pdiscard(rwco->bs, rwco->offset, rwco->bytes);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-07-16 02:22:50 +03:00
|
|
|
int coroutine_fn bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset,
|
2017-06-09 13:18:08 +03:00
|
|
|
int bytes)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
2015-11-09 13:16:48 +03:00
|
|
|
BdrvTrackedRequest req;
|
2016-07-16 02:22:50 +03:00
|
|
|
int max_pdiscard, ret;
|
block: Pass unaligned discard requests to drivers
Discard is advisory, so rounding the requests to alignment
boundaries is never semantically wrong from the data that
the guest sees. But at least the Dell Equallogic iSCSI SANs
has an interesting property that its advertised discard
alignment is 15M, yet documents that discarding a sequence
of 1M slices will eventually result in the 15M page being
marked as discarded, and it is possible to observe which
pages have been discarded.
Between commits 9f1963b and b8d0a980, we converted the block
layer to a byte-based interface that ultimately ignores any
unaligned head or tail based on the driver's advertised
discard granularity, which means that qemu 2.7 refuses to
pass any discard request smaller than 15M down to the Dell
Equallogic hardware. This is a slight regression in behavior
compared to earlier qemu, where a guest executing discards
in power-of-2 chunks used to be able to get every page
discarded, but is now left with various pages still allocated
because the guest requests did not align with the hardware's
15M pages.
Since the SCSI specification says nothing about a minimum
discard granularity, and only documents the preferred
alignment, it is best if the block layer gives the driver
every bit of information about discard requests, rather than
rounding it to alignment boundaries early.
Rework the block layer discard algorithm to mirror the write
zero algorithm: always peel off any unaligned head or tail
and manage that in isolation, then do the bulk of the request
on an aligned boundary. The fallback when the driver returns
-ENOTSUP for an unaligned request is to silently ignore that
portion of the discard request; but for devices that can pass
the partial request all the way down to hardware, this can
result in the hardware coalescing requests and discarding
aligned pages after all.
Reported by: Peter Lieven <pl@kamp.de>
CC: qemu-stable@nongnu.org
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-11-17 23:13:58 +03:00
|
|
|
int head, tail, align;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
if (!bs->drv) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
|
2017-06-28 15:05:10 +03:00
|
|
|
if (bdrv_has_readonly_bitmaps(bs)) {
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
2017-06-09 13:18:08 +03:00
|
|
|
ret = bdrv_check_byte_request(bs, offset, bytes);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
} else if (bs->read_only) {
|
2015-05-07 18:45:48 +03:00
|
|
|
return -EPERM;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
2016-01-13 17:56:06 +03:00
|
|
|
assert(!(bs->open_flags & BDRV_O_INACTIVE));
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
/* Do nothing if disabled. */
|
|
|
|
if (!(bs->open_flags & BDRV_O_UNMAP)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-07-16 02:23:06 +03:00
|
|
|
if (!bs->drv->bdrv_co_pdiscard && !bs->drv->bdrv_aio_pdiscard) {
|
2015-04-28 16:27:52 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
block: Pass unaligned discard requests to drivers
Discard is advisory, so rounding the requests to alignment
boundaries is never semantically wrong from the data that
the guest sees. But at least the Dell Equallogic iSCSI SANs
has an interesting property that its advertised discard
alignment is 15M, yet documents that discarding a sequence
of 1M slices will eventually result in the 15M page being
marked as discarded, and it is possible to observe which
pages have been discarded.
Between commits 9f1963b and b8d0a980, we converted the block
layer to a byte-based interface that ultimately ignores any
unaligned head or tail based on the driver's advertised
discard granularity, which means that qemu 2.7 refuses to
pass any discard request smaller than 15M down to the Dell
Equallogic hardware. This is a slight regression in behavior
compared to earlier qemu, where a guest executing discards
in power-of-2 chunks used to be able to get every page
discarded, but is now left with various pages still allocated
because the guest requests did not align with the hardware's
15M pages.
Since the SCSI specification says nothing about a minimum
discard granularity, and only documents the preferred
alignment, it is best if the block layer gives the driver
every bit of information about discard requests, rather than
rounding it to alignment boundaries early.
Rework the block layer discard algorithm to mirror the write
zero algorithm: always peel off any unaligned head or tail
and manage that in isolation, then do the bulk of the request
on an aligned boundary. The fallback when the driver returns
-ENOTSUP for an unaligned request is to silently ignore that
portion of the discard request; but for devices that can pass
the partial request all the way down to hardware, this can
result in the hardware coalescing requests and discarding
aligned pages after all.
Reported by: Peter Lieven <pl@kamp.de>
CC: qemu-stable@nongnu.org
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-11-17 23:13:58 +03:00
|
|
|
/* Discard is advisory, but some devices track and coalesce
|
|
|
|
* unaligned requests, so we must pass everything down rather than
|
|
|
|
* round here. Still, most devices will just silently ignore
|
|
|
|
* unaligned requests (by returning -ENOTSUP), so we must fragment
|
|
|
|
* the request accordingly. */
|
2016-07-16 02:23:06 +03:00
|
|
|
align = MAX(bs->bl.pdiscard_alignment, bs->bl.request_alignment);
|
2016-07-21 22:34:48 +03:00
|
|
|
assert(align % bs->bl.request_alignment == 0);
|
|
|
|
head = offset % align;
|
2017-06-09 13:18:08 +03:00
|
|
|
tail = (offset + bytes) % align;
|
2016-07-16 02:22:50 +03:00
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_inc_in_flight(bs);
|
2017-06-09 13:18:08 +03:00
|
|
|
tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_DISCARD);
|
2015-06-08 08:56:10 +03:00
|
|
|
|
2016-06-16 19:09:41 +03:00
|
|
|
ret = notifier_with_return_list_notify(&bs->before_write_notifiers, &req);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-07-16 02:22:50 +03:00
|
|
|
max_pdiscard = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_pdiscard, INT_MAX),
|
|
|
|
align);
|
block: Pass unaligned discard requests to drivers
Discard is advisory, so rounding the requests to alignment
boundaries is never semantically wrong from the data that
the guest sees. But at least the Dell Equallogic iSCSI SANs
has an interesting property that its advertised discard
alignment is 15M, yet documents that discarding a sequence
of 1M slices will eventually result in the 15M page being
marked as discarded, and it is possible to observe which
pages have been discarded.
Between commits 9f1963b and b8d0a980, we converted the block
layer to a byte-based interface that ultimately ignores any
unaligned head or tail based on the driver's advertised
discard granularity, which means that qemu 2.7 refuses to
pass any discard request smaller than 15M down to the Dell
Equallogic hardware. This is a slight regression in behavior
compared to earlier qemu, where a guest executing discards
in power-of-2 chunks used to be able to get every page
discarded, but is now left with various pages still allocated
because the guest requests did not align with the hardware's
15M pages.
Since the SCSI specification says nothing about a minimum
discard granularity, and only documents the preferred
alignment, it is best if the block layer gives the driver
every bit of information about discard requests, rather than
rounding it to alignment boundaries early.
Rework the block layer discard algorithm to mirror the write
zero algorithm: always peel off any unaligned head or tail
and manage that in isolation, then do the bulk of the request
on an aligned boundary. The fallback when the driver returns
-ENOTSUP for an unaligned request is to silently ignore that
portion of the discard request; but for devices that can pass
the partial request all the way down to hardware, this can
result in the hardware coalescing requests and discarding
aligned pages after all.
Reported by: Peter Lieven <pl@kamp.de>
CC: qemu-stable@nongnu.org
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-11-17 23:13:58 +03:00
|
|
|
assert(max_pdiscard >= bs->bl.request_alignment);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2017-06-09 13:18:08 +03:00
|
|
|
while (bytes > 0) {
|
|
|
|
int num = bytes;
|
block: Pass unaligned discard requests to drivers
Discard is advisory, so rounding the requests to alignment
boundaries is never semantically wrong from the data that
the guest sees. But at least the Dell Equallogic iSCSI SANs
has an interesting property that its advertised discard
alignment is 15M, yet documents that discarding a sequence
of 1M slices will eventually result in the 15M page being
marked as discarded, and it is possible to observe which
pages have been discarded.
Between commits 9f1963b and b8d0a980, we converted the block
layer to a byte-based interface that ultimately ignores any
unaligned head or tail based on the driver's advertised
discard granularity, which means that qemu 2.7 refuses to
pass any discard request smaller than 15M down to the Dell
Equallogic hardware. This is a slight regression in behavior
compared to earlier qemu, where a guest executing discards
in power-of-2 chunks used to be able to get every page
discarded, but is now left with various pages still allocated
because the guest requests did not align with the hardware's
15M pages.
Since the SCSI specification says nothing about a minimum
discard granularity, and only documents the preferred
alignment, it is best if the block layer gives the driver
every bit of information about discard requests, rather than
rounding it to alignment boundaries early.
Rework the block layer discard algorithm to mirror the write
zero algorithm: always peel off any unaligned head or tail
and manage that in isolation, then do the bulk of the request
on an aligned boundary. The fallback when the driver returns
-ENOTSUP for an unaligned request is to silently ignore that
portion of the discard request; but for devices that can pass
the partial request all the way down to hardware, this can
result in the hardware coalescing requests and discarding
aligned pages after all.
Reported by: Peter Lieven <pl@kamp.de>
CC: qemu-stable@nongnu.org
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-11-17 23:13:58 +03:00
|
|
|
|
|
|
|
if (head) {
|
|
|
|
/* Make small requests to get to alignment boundaries. */
|
2017-06-09 13:18:08 +03:00
|
|
|
num = MIN(bytes, align - head);
|
block: Pass unaligned discard requests to drivers
Discard is advisory, so rounding the requests to alignment
boundaries is never semantically wrong from the data that
the guest sees. But at least the Dell Equallogic iSCSI SANs
has an interesting property that its advertised discard
alignment is 15M, yet documents that discarding a sequence
of 1M slices will eventually result in the 15M page being
marked as discarded, and it is possible to observe which
pages have been discarded.
Between commits 9f1963b and b8d0a980, we converted the block
layer to a byte-based interface that ultimately ignores any
unaligned head or tail based on the driver's advertised
discard granularity, which means that qemu 2.7 refuses to
pass any discard request smaller than 15M down to the Dell
Equallogic hardware. This is a slight regression in behavior
compared to earlier qemu, where a guest executing discards
in power-of-2 chunks used to be able to get every page
discarded, but is now left with various pages still allocated
because the guest requests did not align with the hardware's
15M pages.
Since the SCSI specification says nothing about a minimum
discard granularity, and only documents the preferred
alignment, it is best if the block layer gives the driver
every bit of information about discard requests, rather than
rounding it to alignment boundaries early.
Rework the block layer discard algorithm to mirror the write
zero algorithm: always peel off any unaligned head or tail
and manage that in isolation, then do the bulk of the request
on an aligned boundary. The fallback when the driver returns
-ENOTSUP for an unaligned request is to silently ignore that
portion of the discard request; but for devices that can pass
the partial request all the way down to hardware, this can
result in the hardware coalescing requests and discarding
aligned pages after all.
Reported by: Peter Lieven <pl@kamp.de>
CC: qemu-stable@nongnu.org
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-11-17 23:13:58 +03:00
|
|
|
if (!QEMU_IS_ALIGNED(num, bs->bl.request_alignment)) {
|
|
|
|
num %= bs->bl.request_alignment;
|
|
|
|
}
|
|
|
|
head = (head + num) % align;
|
|
|
|
assert(num < max_pdiscard);
|
|
|
|
} else if (tail) {
|
|
|
|
if (num > align) {
|
|
|
|
/* Shorten the request to the last aligned cluster. */
|
|
|
|
num -= tail;
|
|
|
|
} else if (!QEMU_IS_ALIGNED(tail, bs->bl.request_alignment) &&
|
|
|
|
tail > bs->bl.request_alignment) {
|
|
|
|
tail %= bs->bl.request_alignment;
|
|
|
|
num -= tail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* limit request size */
|
|
|
|
if (num > max_pdiscard) {
|
|
|
|
num = max_pdiscard;
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-07-16 02:22:58 +03:00
|
|
|
if (bs->drv->bdrv_co_pdiscard) {
|
|
|
|
ret = bs->drv->bdrv_co_pdiscard(bs, offset, num);
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
|
|
|
BlockAIOCB *acb;
|
|
|
|
CoroutineIOCompletion co = {
|
|
|
|
.coroutine = qemu_coroutine_self(),
|
|
|
|
};
|
|
|
|
|
2016-07-16 02:22:57 +03:00
|
|
|
acb = bs->drv->bdrv_aio_pdiscard(bs, offset, num,
|
|
|
|
bdrv_co_io_em_complete, &co);
|
2015-04-28 16:27:52 +03:00
|
|
|
if (acb == NULL) {
|
2015-11-09 13:16:48 +03:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
ret = co.ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ret && ret != -ENOTSUP) {
|
2015-11-09 13:16:48 +03:00
|
|
|
goto out;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2016-07-16 02:22:50 +03:00
|
|
|
offset += num;
|
2017-06-09 13:18:08 +03:00
|
|
|
bytes -= num;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
2015-11-09 13:16:48 +03:00
|
|
|
ret = 0;
|
|
|
|
out:
|
2017-06-05 15:39:01 +03:00
|
|
|
atomic_inc(&bs->write_gen);
|
2016-06-16 19:09:40 +03:00
|
|
|
bdrv_set_dirty(bs, req.offset >> BDRV_SECTOR_BITS,
|
|
|
|
req.bytes >> BDRV_SECTOR_BITS);
|
2015-11-09 13:16:48 +03:00
|
|
|
tracked_request_end(&req);
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_dec_in_flight(bs);
|
2015-11-09 13:16:48 +03:00
|
|
|
return ret;
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
2017-06-09 13:18:08 +03:00
|
|
|
int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
Coroutine *co;
|
|
|
|
DiscardCo rwco = {
|
|
|
|
.bs = bs,
|
2016-07-16 02:22:51 +03:00
|
|
|
.offset = offset,
|
2017-06-09 13:18:08 +03:00
|
|
|
.bytes = bytes,
|
2015-04-28 16:27:52 +03:00
|
|
|
.ret = NOT_DONE,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
/* Fast-path if already in coroutine context */
|
2016-07-16 02:22:51 +03:00
|
|
|
bdrv_pdiscard_co_entry(&rwco);
|
2015-04-28 16:27:52 +03:00
|
|
|
} else {
|
2016-07-16 02:22:51 +03:00
|
|
|
co = qemu_coroutine_create(bdrv_pdiscard_co_entry, &rwco);
|
block: Use bdrv_coroutine_enter to start I/O coroutines
BDRV_POLL_WHILE waits for the started I/O by releasing bs's ctx then polling
the main context, which relies on the yielded coroutine continuing on bs->ctx
before notifying qemu_aio_context with bdrv_wakeup().
Thus, using qemu_coroutine_enter to start I/O is wrong because if the coroutine
is entered from main loop, co->ctx will be qemu_aio_context, as a result of the
"release, poll, acquire" loop of BDRV_POLL_WHILE, race conditions happen when
both main thread and the iothread access the same BDS:
main loop iothread
-----------------------------------------------------------------------
blockdev_snapshot
aio_context_acquire(bs->ctx)
virtio_scsi_data_plane_handle_cmd
bdrv_drained_begin(bs->ctx)
bdrv_flush(bs)
bdrv_co_flush(bs) aio_context_acquire(bs->ctx).enter
...
qemu_coroutine_yield(co)
BDRV_POLL_WHILE()
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx).return
...
aio_co_wake(co)
aio_poll(qemu_aio_context) ...
co_schedule_bh_cb() ...
qemu_coroutine_enter(co) ...
/* (A) bdrv_co_flush(bs) /* (B) I/O on bs */
continues... */
aio_context_release(bs->ctx)
aio_context_acquire(bs->ctx)
Note that in above case, bdrv_drained_begin() doesn't do the "release,
poll, acquire" in BDRV_POLL_WHILE, because bs->in_flight == 0.
Fix this by using bdrv_coroutine_enter and enter coroutine in the right
context.
iotests 109 output is updated because the coroutine reenter flow during
mirror job complete is different (now through co_queue_wakeup, instead
of the unconditional qemu_coroutine_switch before), making the end job
len different.
Signed-off-by: Fam Zheng <famz@redhat.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
2017-04-10 15:20:17 +03:00
|
|
|
bdrv_coroutine_enter(bs, co);
|
2016-10-27 13:48:55 +03:00
|
|
|
BDRV_POLL_WHILE(bs, rwco.ret == NOT_DONE);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return rwco.ret;
|
|
|
|
}
|
|
|
|
|
2016-10-20 13:56:14 +03:00
|
|
|
int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf)
|
2015-04-28 16:27:52 +03:00
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
2015-11-09 13:16:51 +03:00
|
|
|
CoroutineIOCompletion co = {
|
|
|
|
.coroutine = qemu_coroutine_self(),
|
|
|
|
};
|
|
|
|
BlockAIOCB *acb;
|
2015-04-28 16:27:52 +03:00
|
|
|
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_inc_in_flight(bs);
|
2016-10-20 16:07:27 +03:00
|
|
|
if (!drv || (!drv->bdrv_aio_ioctl && !drv->bdrv_co_ioctl)) {
|
2015-11-09 13:16:51 +03:00
|
|
|
co.ret = -ENOTSUP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-10-20 16:07:27 +03:00
|
|
|
if (drv->bdrv_co_ioctl) {
|
|
|
|
co.ret = drv->bdrv_co_ioctl(bs, req, buf);
|
|
|
|
} else {
|
|
|
|
acb = drv->bdrv_aio_ioctl(bs, req, buf, bdrv_co_io_em_complete, &co);
|
|
|
|
if (!acb) {
|
|
|
|
co.ret = -ENOTSUP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
qemu_coroutine_yield();
|
2015-11-09 13:16:51 +03:00
|
|
|
}
|
|
|
|
out:
|
2016-10-27 13:48:52 +03:00
|
|
|
bdrv_dec_in_flight(bs);
|
2015-11-09 13:16:51 +03:00
|
|
|
return co.ret;
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:27:52 +03:00
|
|
|
void *qemu_blockalign(BlockDriverState *bs, size_t size)
|
|
|
|
{
|
|
|
|
return qemu_memalign(bdrv_opt_mem_align(bs), size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *qemu_blockalign0(BlockDriverState *bs, size_t size)
|
|
|
|
{
|
|
|
|
return memset(qemu_blockalign(bs, size), 0, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
|
|
|
|
{
|
|
|
|
size_t align = bdrv_opt_mem_align(bs);
|
|
|
|
|
|
|
|
/* Ensure that NULL is never returned on success */
|
|
|
|
assert(align > 0);
|
|
|
|
if (size == 0) {
|
|
|
|
size = align;
|
|
|
|
}
|
|
|
|
|
|
|
|
return qemu_try_memalign(align, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *qemu_try_blockalign0(BlockDriverState *bs, size_t size)
|
|
|
|
{
|
|
|
|
void *mem = qemu_try_blockalign(bs, size);
|
|
|
|
|
|
|
|
if (mem) {
|
|
|
|
memset(mem, 0, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if all memory in this vector is sector aligned.
|
|
|
|
*/
|
|
|
|
bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
|
|
|
|
{
|
|
|
|
int i;
|
2015-05-12 17:30:55 +03:00
|
|
|
size_t alignment = bdrv_min_mem_align(bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
|
|
|
|
for (i = 0; i < qiov->niov; i++) {
|
|
|
|
if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (qiov->iov[i].iov_len % alignment) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_add_before_write_notifier(BlockDriverState *bs,
|
|
|
|
NotifierWithReturn *notifier)
|
|
|
|
{
|
|
|
|
notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_io_plug(BlockDriverState *bs)
|
|
|
|
{
|
2016-04-07 19:33:34 +03:00
|
|
|
BdrvChild *child;
|
|
|
|
|
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
bdrv_io_plug(child->bs);
|
|
|
|
}
|
|
|
|
|
2017-06-05 15:38:55 +03:00
|
|
|
if (atomic_fetch_inc(&bs->io_plugged) == 0) {
|
2016-04-07 19:33:34 +03:00
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
if (drv && drv->bdrv_io_plug) {
|
|
|
|
drv->bdrv_io_plug(bs);
|
|
|
|
}
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_io_unplug(BlockDriverState *bs)
|
|
|
|
{
|
2016-04-07 19:33:34 +03:00
|
|
|
BdrvChild *child;
|
|
|
|
|
|
|
|
assert(bs->io_plugged);
|
2017-06-05 15:38:55 +03:00
|
|
|
if (atomic_fetch_dec(&bs->io_plugged) == 1) {
|
2016-04-07 19:33:34 +03:00
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
if (drv && drv->bdrv_io_unplug) {
|
|
|
|
drv->bdrv_io_unplug(bs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
bdrv_io_unplug(child->bs);
|
2015-04-28 16:27:52 +03:00
|
|
|
}
|
|
|
|
}
|