From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:46207) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1VrSih-0007L9-Dx for qemu-devel@nongnu.org; Fri, 13 Dec 2013 08:24:01 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1VrSia-0002CS-M9 for qemu-devel@nongnu.org; Fri, 13 Dec 2013 08:23:55 -0500 Received: from mx1.redhat.com ([209.132.183.28]:46257) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1VrSia-0002C9-Ds for qemu-devel@nongnu.org; Fri, 13 Dec 2013 08:23:48 -0500 From: Kevin Wolf Date: Fri, 13 Dec 2013 14:22:54 +0100 Message-Id: <1386940979-3824-20-git-send-email-kwolf@redhat.com> In-Reply-To: <1386940979-3824-1-git-send-email-kwolf@redhat.com> References: <1386940979-3824-1-git-send-email-kwolf@redhat.com> Subject: [Qemu-devel] [PATCH v2 19/24] block: Allow wait_serialising_requests() at any point List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: kwolf@redhat.com, pbonzini@redhat.com, pl@kamp.de, stefanha@redhat.com We can only have a single wait_serialising_requests() call per request because otherwise we can run into deadlocks where requests are waiting for each other. The same is true when wait_serialising_requests() is not at the very beginning of a request, so that other requests can be issued between the start of the tracking and wait_serialising_requests(). Fix this by changing wait_serialising_requests() to ignore requests that are already (directly or indirectly) waiting for the calling request. Signed-off-by: Kevin Wolf --- block.c | 26 +++++++++++++++++++++++--- include/block/block_int.h | 2 ++ 2 files changed, 25 insertions(+), 3 deletions(-) diff --git a/block.c b/block.c index 73bba47..8a0225d 100644 --- a/block.c +++ b/block.c @@ -2123,6 +2123,20 @@ static bool tracked_request_overlaps(BdrvTrackedRequest *req, return true; } +static bool coroutine_fn is_waiting_for(BdrvTrackedRequest *waiting, + BdrvTrackedRequest *waited_for) +{ + BdrvTrackedRequest *req; + + for (req = waiting; req != NULL; req = req->waiting_for) { + if (req == waited_for) { + return true; + } + } + + return false; +} + static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) { BlockDriverState *bs = self->bs; @@ -2148,9 +2162,15 @@ static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) */ assert(qemu_coroutine_self() != req->co); - qemu_co_queue_wait(&req->wait_queue); - retry = true; - break; + /* If the request is already (indircetly) waiting for us, then + * just go on instead of producing a deadlock. */ + if (!is_waiting_for(req, self)) { + self->waiting_for = req; + qemu_co_queue_wait(&req->wait_queue); + self->waiting_for = NULL; + retry = true; + break; + } } } } while (retry); diff --git a/include/block/block_int.h b/include/block/block_int.h index 1aee02b..0f7fcef 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -68,6 +68,8 @@ typedef struct BdrvTrackedRequest { QLIST_ENTRY(BdrvTrackedRequest) list; Coroutine *co; /* owner, used for deadlock detection */ CoQueue wait_queue; /* coroutines blocked on this request */ + + struct BdrvTrackedRequest *waiting_for; } BdrvTrackedRequest; struct BlockDriver { -- 1.8.1.4