From: Paolo Bonzini <pbonzini@redhat.com>
To: qemu-devel@nongnu.org
Cc: kwolf@redhat.com, Peter Lieven <pl@kamp.de>, qemu-block@redhat.com
Subject: [PATCH 2/3] block/io: wait for serialising requests when a request becomes serialising
Date: Wed, 18 Dec 2019 14:17:05 +0100 [thread overview]
Message-ID: <1576675026-25046-3-git-send-email-pbonzini@redhat.com> (raw)
In-Reply-To: <1576675026-25046-1-git-send-email-pbonzini@redhat.com>
Marking without waiting would not result in actual serialising behavior.
Thus, make a call bdrv_mark_request_serialising sufficient for
serialisation to happen.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
block/file-posix.c | 1 -
block/io.c | 39 ++++++++++++++++-----------------------
include/block/block_int.h | 3 +--
3 files changed, 17 insertions(+), 26 deletions(-)
diff --git a/block/file-posix.c b/block/file-posix.c
index 1b805bd..2b08b02 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -2753,7 +2753,6 @@ raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
req->overlap_bytes = req->bytes;
bdrv_mark_request_serialising(req, bs->bl.request_alignment);
- bdrv_wait_serialising_requests(req);
}
#endif
diff --git a/block/io.c b/block/io.c
index b3a67fe..e844c4b 100644
--- a/block/io.c
+++ b/block/io.c
@@ -41,6 +41,7 @@
#define MAX_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)
static void bdrv_parent_cb_resize(BlockDriverState *bs);
+static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
int64_t offset, int bytes, BdrvRequestFlags flags);
@@ -715,7 +716,7 @@ static void tracked_request_begin(BdrvTrackedRequest *req,
qemu_co_mutex_unlock(&bs->reqs_lock);
}
-void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
+bool bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
{
int64_t overlap_offset = req->offset & ~(align - 1);
uint64_t overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
@@ -728,18 +729,7 @@ void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
-}
-
-static bool is_request_serialising_and_aligned(BdrvTrackedRequest *req)
-{
- /*
- * If the request is serialising, overlap_offset and overlap_bytes are set,
- * so we can check if the request is aligned. Otherwise, don't care and
- * return false.
- */
-
- return req->serialising && (req->offset == req->overlap_offset) &&
- (req->bytes == req->overlap_bytes);
+ return bdrv_wait_serialising_requests(req);
}
/**
@@ -823,7 +813,7 @@ void bdrv_dec_in_flight(BlockDriverState *bs)
bdrv_wakeup(bs);
}
-bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
+static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
{
BlockDriverState *bs = self->bs;
BdrvTrackedRequest *req;
@@ -1455,10 +1445,10 @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
* it ensures that the CoR read and write operations are atomic and
* guest writes cannot interleave between them. */
bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
+ } else {
+ bdrv_wait_serialising_requests(req);
}
- bdrv_wait_serialising_requests(req);
-
if (flags & BDRV_REQ_COPY_ON_READ) {
int64_t pnum;
@@ -1851,13 +1841,18 @@ bdrv_co_write_req_prepare(BdrvChild *child, int64_t offset, uint64_t bytes,
assert(!(flags & ~BDRV_REQ_MASK));
if (flags & BDRV_REQ_SERIALISING) {
- bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
+ waited = bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
+ /*
+ * For a misaligned request, we should have already waited
+ * in bdrv_padding_rmw_read and locked out concurrent writers.
+ */
+ assert(!waited ||
+ (req->offset == req->overlap_offset &&
+ req->bytes == req->overlap_bytes));
+ } else {
+ bdrv_wait_serialising_requests(req);
}
- waited = bdrv_wait_serialising_requests(req);
-
- assert(!waited || !req->serialising ||
- is_request_serialising_and_aligned(req));
assert(req->overlap_offset <= offset);
assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
assert(end_sector <= bs->total_sectors || child->perm & BLK_PERM_RESIZE);
@@ -2019,7 +2014,6 @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
padding = bdrv_init_padding(bs, offset, bytes, &pad);
if (padding) {
bdrv_mark_request_serialising(req, align);
- bdrv_wait_serialising_requests(req);
bdrv_padding_rmw_read(child, req, &pad, true);
@@ -2122,7 +2116,6 @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
if (bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad)) {
bdrv_mark_request_serialising(&req, align);
- bdrv_wait_serialising_requests(&req);
bdrv_padding_rmw_read(child, &req, &pad, false);
}
diff --git a/include/block/block_int.h b/include/block/block_int.h
index dd033d0..640fb82 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -999,8 +999,7 @@ extern unsigned int bdrv_drain_all_count;
void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent);
void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent);
-bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
-void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align);
+bool coroutine_fn bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align);
BdrvTrackedRequest *coroutine_fn bdrv_co_get_self_request(BlockDriverState *bs);
int get_tmp_filename(char *filename, int size);
--
1.8.3.1
next prev parent reply other threads:[~2019-12-18 13:19 UTC|newest]
Thread overview: 10+ messages / expand[flat|nested] mbox.gz Atom feed top
2019-12-18 13:17 [PATCH 0/3] block/io: serialising request clean up and locking fix Paolo Bonzini
2019-12-18 13:17 ` [PATCH 1/3] block: eliminate BDRV_REQ_NO_SERIALISING Paolo Bonzini
2019-12-18 16:37 ` Kevin Wolf
2019-12-18 16:43 ` Paolo Bonzini
2019-12-18 16:51 ` Kevin Wolf
2019-12-18 13:17 ` Paolo Bonzini [this message]
2019-12-18 16:47 ` [PATCH 2/3] block/io: wait for serialising requests when a request becomes serialising Kevin Wolf
2019-12-18 13:17 ` [PATCH 3/3] block/io: take bs->reqs_lock in bdrv_mark_request_serialising Paolo Bonzini
2019-12-18 16:59 ` Kevin Wolf
2019-12-18 17:21 ` Paolo Bonzini
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1576675026-25046-3-git-send-email-pbonzini@redhat.com \
--to=pbonzini@redhat.com \
--cc=kwolf@redhat.com \
--cc=pl@kamp.de \
--cc=qemu-block@redhat.com \
--cc=qemu-devel@nongnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).