2008-12-04 22:52:44 +03:00
|
|
|
/*
|
|
|
|
* Virtio Block Device
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2007
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-01-18 21:01:42 +03:00
|
|
|
#include "qemu/osdep.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"
|
2014-06-11 08:11:48 +04:00
|
|
|
#include "qemu/iov.h"
|
2019-05-23 17:35:07 +03:00
|
|
|
#include "qemu/module.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/error-report.h"
|
2019-09-16 14:24:12 +03:00
|
|
|
#include "qemu/main-loop.h"
|
2010-05-22 21:15:08 +04:00
|
|
|
#include "trace.h"
|
2013-02-05 20:06:20 +04:00
|
|
|
#include "hw/block/block.h"
|
2019-08-12 08:23:51 +03:00
|
|
|
#include "hw/qdev-properties.h"
|
2012-12-17 21:20:04 +04:00
|
|
|
#include "sysemu/blockdev.h"
|
2019-08-12 08:23:58 +03:00
|
|
|
#include "sysemu/sysemu.h"
|
2019-08-12 08:23:59 +03:00
|
|
|
#include "sysemu/runstate.h"
|
2013-02-05 20:06:20 +04:00
|
|
|
#include "hw/virtio/virtio-blk.h"
|
2014-09-10 10:17:51 +04:00
|
|
|
#include "dataplane/virtio-blk.h"
|
2017-08-22 10:23:55 +03:00
|
|
|
#include "scsi/constants.h"
|
2009-04-27 12:29:14 +04:00
|
|
|
#ifdef __linux__
|
|
|
|
# include <scsi/sg.h>
|
|
|
|
#endif
|
2013-02-05 20:06:20 +04:00
|
|
|
#include "hw/virtio/virtio-bus.h"
|
2019-08-12 08:23:39 +03:00
|
|
|
#include "migration/qemu-file-types.h"
|
2014-06-24 21:43:44 +04:00
|
|
|
#include "hw/virtio/virtio-access.h"
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2019-02-21 13:33:09 +03:00
|
|
|
/* Config size before the discard support (hide associated config fields) */
|
2019-02-13 04:48:57 +03:00
|
|
|
#define VIRTIO_BLK_CFG_SIZE offsetof(struct virtio_blk_config, \
|
|
|
|
max_discard_sectors)
|
2019-02-21 13:33:09 +03:00
|
|
|
/*
|
|
|
|
* Starting from the discard feature, we can use this array to properly
|
|
|
|
* set the config size depending on the features enabled.
|
|
|
|
*/
|
|
|
|
static VirtIOFeature feature_sizes[] = {
|
|
|
|
{.flags = 1ULL << VIRTIO_BLK_F_DISCARD,
|
2019-10-11 18:27:59 +03:00
|
|
|
.end = endof(struct virtio_blk_config, discard_sector_alignment)},
|
2019-02-21 13:33:09 +03:00
|
|
|
{.flags = 1ULL << VIRTIO_BLK_F_WRITE_ZEROES,
|
2019-10-11 18:27:59 +03:00
|
|
|
.end = endof(struct virtio_blk_config, write_zeroes_may_unmap)},
|
2019-02-21 13:33:09 +03:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static void virtio_blk_set_config_size(VirtIOBlock *s, uint64_t host_features)
|
|
|
|
{
|
|
|
|
s->config_size = MAX(VIRTIO_BLK_CFG_SIZE,
|
|
|
|
virtio_feature_get_config_size(feature_sizes, host_features));
|
|
|
|
|
|
|
|
assert(s->config_size <= sizeof(struct virtio_blk_config));
|
|
|
|
}
|
2019-02-13 04:48:57 +03:00
|
|
|
|
2016-09-30 18:12:50 +03:00
|
|
|
static void virtio_blk_init_request(VirtIOBlock *s, VirtQueue *vq,
|
|
|
|
VirtIOBlockReq *req)
|
2014-06-11 08:11:43 +04:00
|
|
|
{
|
|
|
|
req->dev = s;
|
2016-06-21 15:13:13 +03:00
|
|
|
req->vq = vq;
|
2014-07-09 12:05:48 +04:00
|
|
|
req->qiov.size = 0;
|
2015-04-02 20:50:44 +03:00
|
|
|
req->in_len = 0;
|
2014-07-09 12:05:48 +04:00
|
|
|
req->next = NULL;
|
2015-02-02 16:52:21 +03:00
|
|
|
req->mr_next = NULL;
|
2014-06-11 08:11:43 +04:00
|
|
|
}
|
|
|
|
|
2016-09-30 18:12:50 +03:00
|
|
|
static void virtio_blk_free_request(VirtIOBlockReq *req)
|
2014-06-11 08:11:43 +04:00
|
|
|
{
|
2017-02-07 16:27:22 +03:00
|
|
|
g_free(req);
|
2014-06-11 08:11:43 +04:00
|
|
|
}
|
|
|
|
|
2016-02-14 20:17:09 +03:00
|
|
|
static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status)
|
2009-01-22 22:52:25 +03:00
|
|
|
{
|
|
|
|
VirtIOBlock *s = req->dev;
|
2013-03-18 20:37:27 +04:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
2009-01-22 22:52:25 +03:00
|
|
|
|
2017-06-14 12:29:30 +03:00
|
|
|
trace_virtio_blk_req_complete(vdev, req, status);
|
2010-05-22 21:15:08 +04:00
|
|
|
|
2011-01-25 13:55:14 +03:00
|
|
|
stb_p(&req->in->status, status);
|
2016-06-21 15:13:13 +03:00
|
|
|
virtqueue_push(req->vq, &req->elem, req->in_len);
|
2016-04-06 13:16:23 +03:00
|
|
|
if (s->dataplane_started && !s->dataplane_disabled) {
|
2016-06-21 15:13:13 +03:00
|
|
|
virtio_blk_data_plane_notify(s->dataplane, req->vq);
|
2016-02-14 20:17:09 +03:00
|
|
|
} else {
|
2016-06-21 15:13:13 +03:00
|
|
|
virtio_notify(vdev, req->vq);
|
2016-02-14 20:17:09 +03:00
|
|
|
}
|
2014-06-17 10:32:06 +04:00
|
|
|
}
|
|
|
|
|
2009-11-27 15:25:39 +03:00
|
|
|
static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
|
2019-02-21 13:33:05 +03:00
|
|
|
bool is_read, bool acct_failed)
|
2009-01-22 22:52:25 +03:00
|
|
|
{
|
|
|
|
VirtIOBlock *s = req->dev;
|
2019-02-08 17:23:47 +03:00
|
|
|
BlockErrorAction action = blk_get_error_action(s->blk, is_read, error);
|
2009-01-22 22:52:25 +03:00
|
|
|
|
2014-06-18 10:43:30 +04:00
|
|
|
if (action == BLOCK_ERROR_ACTION_STOP) {
|
2015-11-23 03:41:20 +03:00
|
|
|
/* Break the link as the next request is going to be parsed from the
|
|
|
|
* ring again. Otherwise we may end up doing a double completion! */
|
|
|
|
req->mr_next = NULL;
|
2009-01-22 22:52:25 +03:00
|
|
|
req->next = s->rq;
|
|
|
|
s->rq = req;
|
2014-06-18 10:43:30 +04:00
|
|
|
} else if (action == BLOCK_ERROR_ACTION_REPORT) {
|
2009-01-22 22:52:25 +03:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
|
2019-02-21 13:33:05 +03:00
|
|
|
if (acct_failed) {
|
|
|
|
block_acct_failed(blk_get_stats(s->blk), &req->acct);
|
|
|
|
}
|
2014-06-11 08:11:43 +04:00
|
|
|
virtio_blk_free_request(req);
|
2009-01-22 22:52:25 +03:00
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
blk_error_action(s->blk, action, is_read, error);
|
2014-06-18 10:43:30 +04:00
|
|
|
return action != BLOCK_ERROR_ACTION_IGNORE;
|
2009-01-22 22:52:25 +03:00
|
|
|
}
|
|
|
|
|
2008-12-04 22:52:44 +03:00
|
|
|
static void virtio_blk_rw_complete(void *opaque, int ret)
|
|
|
|
{
|
2015-02-02 16:52:21 +03:00
|
|
|
VirtIOBlockReq *next = opaque;
|
2017-02-13 16:52:32 +03:00
|
|
|
VirtIOBlock *s = next->dev;
|
2017-06-14 12:29:30 +03:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
2015-02-02 16:52:21 +03:00
|
|
|
|
2017-02-13 16:52:32 +03:00
|
|
|
aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
|
2015-02-02 16:52:21 +03:00
|
|
|
while (next) {
|
|
|
|
VirtIOBlockReq *req = next;
|
|
|
|
next = req->mr_next;
|
2017-06-14 12:29:30 +03:00
|
|
|
trace_virtio_blk_rw_complete(vdev, req, ret);
|
2015-02-02 16:52:21 +03:00
|
|
|
|
|
|
|
if (req->qiov.nalloc != -1) {
|
2018-11-06 07:52:32 +03:00
|
|
|
/* If nalloc is != -1 req->qiov is a local copy of the original
|
2018-07-28 08:18:44 +03:00
|
|
|
* external iovec. It was allocated in submit_requests to be
|
|
|
|
* able to merge requests. */
|
2015-02-02 16:52:21 +03:00
|
|
|
qemu_iovec_destroy(&req->qiov);
|
|
|
|
}
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
if (ret) {
|
2019-03-07 19:19:25 +03:00
|
|
|
int p = virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type);
|
2015-02-02 16:52:21 +03:00
|
|
|
bool is_read = !(p & VIRTIO_BLK_T_OUT);
|
2015-04-02 20:50:44 +03:00
|
|
|
/* Note that memory may be dirtied on read failure. If the
|
|
|
|
* virtio request is not completed here, as is the case for
|
|
|
|
* BLOCK_ERROR_ACTION_STOP, the memory may not be copied
|
|
|
|
* correctly during live migration. While this is ugly,
|
|
|
|
* it is acceptable because the device is free to write to
|
|
|
|
* the memory until the request is completed (which will
|
|
|
|
* happen on the other side of the migration).
|
|
|
|
*/
|
2019-02-21 13:33:05 +03:00
|
|
|
if (virtio_blk_handle_rw_error(req, -ret, is_read, true)) {
|
2015-02-02 16:52:21 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2010-05-22 21:15:08 +04:00
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
|
2019-03-07 19:19:25 +03:00
|
|
|
block_acct_done(blk_get_stats(s->blk), &req->acct);
|
2015-02-02 16:52:21 +03:00
|
|
|
virtio_blk_free_request(req);
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
2017-02-13 16:52:32 +03:00
|
|
|
aio_context_release(blk_get_aio_context(s->conf.conf.blk));
|
2009-01-22 22:52:25 +03:00
|
|
|
}
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2009-09-04 21:02:23 +04:00
|
|
|
static void virtio_blk_flush_complete(void *opaque, int ret)
|
|
|
|
{
|
|
|
|
VirtIOBlockReq *req = opaque;
|
2017-02-13 16:52:32 +03:00
|
|
|
VirtIOBlock *s = req->dev;
|
2009-09-04 21:02:23 +04:00
|
|
|
|
2017-02-13 16:52:32 +03:00
|
|
|
aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
|
2010-10-20 15:17:30 +04:00
|
|
|
if (ret) {
|
2019-02-21 13:33:05 +03:00
|
|
|
if (virtio_blk_handle_rw_error(req, -ret, 0, true)) {
|
2017-02-13 16:52:32 +03:00
|
|
|
goto out;
|
2010-10-20 15:17:30 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
|
2019-02-08 17:23:47 +03:00
|
|
|
block_acct_done(blk_get_stats(s->blk), &req->acct);
|
2014-06-11 08:11:43 +04:00
|
|
|
virtio_blk_free_request(req);
|
2017-02-13 16:52:32 +03:00
|
|
|
|
|
|
|
out:
|
|
|
|
aio_context_release(blk_get_aio_context(s->conf.conf.blk));
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
|
|
|
|
2019-02-21 13:33:10 +03:00
|
|
|
static void virtio_blk_discard_write_zeroes_complete(void *opaque, int ret)
|
|
|
|
{
|
|
|
|
VirtIOBlockReq *req = opaque;
|
|
|
|
VirtIOBlock *s = req->dev;
|
|
|
|
bool is_write_zeroes = (virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type) &
|
|
|
|
~VIRTIO_BLK_T_BARRIER) == VIRTIO_BLK_T_WRITE_ZEROES;
|
|
|
|
|
|
|
|
aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
|
|
|
|
if (ret) {
|
|
|
|
if (virtio_blk_handle_rw_error(req, -ret, false, is_write_zeroes)) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
|
|
|
|
if (is_write_zeroes) {
|
|
|
|
block_acct_done(blk_get_stats(s->blk), &req->acct);
|
|
|
|
}
|
|
|
|
virtio_blk_free_request(req);
|
|
|
|
|
|
|
|
out:
|
|
|
|
aio_context_release(blk_get_aio_context(s->conf.conf.blk));
|
|
|
|
}
|
|
|
|
|
2015-01-20 06:28:47 +03:00
|
|
|
#ifdef __linux__
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
VirtIOBlockReq *req;
|
|
|
|
struct sg_io_hdr hdr;
|
|
|
|
} VirtIOBlockIoctlReq;
|
|
|
|
|
|
|
|
static void virtio_blk_ioctl_complete(void *opaque, int status)
|
|
|
|
{
|
|
|
|
VirtIOBlockIoctlReq *ioctl_req = opaque;
|
|
|
|
VirtIOBlockReq *req = ioctl_req->req;
|
2017-02-13 16:52:30 +03:00
|
|
|
VirtIOBlock *s = req->dev;
|
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
2015-01-20 06:28:47 +03:00
|
|
|
struct virtio_scsi_inhdr *scsi;
|
|
|
|
struct sg_io_hdr *hdr;
|
|
|
|
|
|
|
|
scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base;
|
|
|
|
|
|
|
|
if (status) {
|
|
|
|
status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
virtio_stl_p(vdev, &scsi->errors, 255);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
hdr = &ioctl_req->hdr;
|
|
|
|
/*
|
|
|
|
* From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi)
|
|
|
|
* clear the masked_status field [hence status gets cleared too, see
|
|
|
|
* block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED
|
|
|
|
* status has occurred. However they do set DRIVER_SENSE in driver_status
|
|
|
|
* field. Also a (sb_len_wr > 0) indicates there is a sense buffer.
|
|
|
|
*/
|
|
|
|
if (hdr->status == 0 && hdr->sb_len_wr > 0) {
|
|
|
|
hdr->status = CHECK_CONDITION;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtio_stl_p(vdev, &scsi->errors,
|
|
|
|
hdr->status | (hdr->msg_status << 8) |
|
|
|
|
(hdr->host_status << 16) | (hdr->driver_status << 24));
|
|
|
|
virtio_stl_p(vdev, &scsi->residual, hdr->resid);
|
|
|
|
virtio_stl_p(vdev, &scsi->sense_len, hdr->sb_len_wr);
|
|
|
|
virtio_stl_p(vdev, &scsi->data_len, hdr->dxfer_len);
|
|
|
|
|
|
|
|
out:
|
2017-02-13 16:52:32 +03:00
|
|
|
aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
|
2015-01-20 06:28:47 +03:00
|
|
|
virtio_blk_req_complete(req, status);
|
|
|
|
virtio_blk_free_request(req);
|
2017-02-13 16:52:32 +03:00
|
|
|
aio_context_release(blk_get_aio_context(s->conf.conf.blk));
|
2015-01-20 06:28:47 +03:00
|
|
|
g_free(ioctl_req);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2016-06-21 15:13:13 +03:00
|
|
|
static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s, VirtQueue *vq)
|
2008-12-04 22:52:44 +03:00
|
|
|
{
|
2016-06-21 15:13:13 +03:00
|
|
|
VirtIOBlockReq *req = virtqueue_pop(vq, sizeof(VirtIOBlockReq));
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2016-02-04 17:26:51 +03:00
|
|
|
if (req) {
|
2016-06-21 15:13:13 +03:00
|
|
|
virtio_blk_init_request(s, vq, req);
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
2015-01-20 06:28:46 +03:00
|
|
|
static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req)
|
2009-04-27 12:29:14 +04:00
|
|
|
{
|
2014-05-22 12:22:42 +04:00
|
|
|
int status = VIRTIO_BLK_S_OK;
|
|
|
|
struct virtio_scsi_inhdr *scsi = NULL;
|
2015-01-20 06:28:46 +03:00
|
|
|
VirtIOBlock *blk = req->dev;
|
2019-03-07 19:19:25 +03:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(blk);
|
|
|
|
VirtQueueElement *elem = &req->elem;
|
2014-06-24 21:43:44 +04:00
|
|
|
|
2012-05-23 01:23:32 +04:00
|
|
|
#ifdef __linux__
|
2009-04-27 12:29:14 +04:00
|
|
|
int i;
|
2015-01-20 06:28:47 +03:00
|
|
|
VirtIOBlockIoctlReq *ioctl_req;
|
2015-02-17 12:55:53 +03:00
|
|
|
BlockAIOCB *acb;
|
2012-05-23 01:23:32 +04:00
|
|
|
#endif
|
2009-04-27 12:29:14 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We require at least one output segment each for the virtio_blk_outhdr
|
|
|
|
* and the SCSI command block.
|
|
|
|
*
|
|
|
|
* We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
|
|
|
|
* and the sense buffer pointer in the input segments.
|
|
|
|
*/
|
2014-05-22 12:22:42 +04:00
|
|
|
if (elem->out_num < 2 || elem->in_num < 3) {
|
|
|
|
status = VIRTIO_BLK_S_IOERR;
|
|
|
|
goto fail;
|
2009-04-27 12:29:14 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-05-16 14:54:03 +04:00
|
|
|
* The scsi inhdr is placed in the second-to-last input segment, just
|
|
|
|
* before the regular inhdr.
|
2009-04-27 12:29:14 +04:00
|
|
|
*/
|
2014-05-22 12:22:42 +04:00
|
|
|
scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base;
|
2012-05-16 14:54:03 +04:00
|
|
|
|
2019-02-21 13:33:06 +03:00
|
|
|
if (!virtio_has_feature(blk->host_features, VIRTIO_BLK_F_SCSI)) {
|
2012-05-16 14:54:03 +04:00
|
|
|
status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
goto fail;
|
2009-04-27 12:29:14 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-05-16 14:54:03 +04:00
|
|
|
* No support for bidirection commands yet.
|
2009-04-27 12:29:14 +04:00
|
|
|
*/
|
2014-05-22 12:22:42 +04:00
|
|
|
if (elem->out_num > 2 && elem->in_num > 3) {
|
2012-05-16 14:54:03 +04:00
|
|
|
status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
goto fail;
|
|
|
|
}
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2012-05-16 14:54:03 +04:00
|
|
|
#ifdef __linux__
|
2015-01-20 06:28:47 +03:00
|
|
|
ioctl_req = g_new0(VirtIOBlockIoctlReq, 1);
|
|
|
|
ioctl_req->req = req;
|
|
|
|
ioctl_req->hdr.interface_id = 'S';
|
|
|
|
ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len;
|
|
|
|
ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base;
|
|
|
|
ioctl_req->hdr.dxfer_len = 0;
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2014-05-22 12:22:42 +04:00
|
|
|
if (elem->out_num > 2) {
|
2009-04-27 12:29:14 +04:00
|
|
|
/*
|
|
|
|
* If there are more than the minimally required 2 output segments
|
|
|
|
* there is write payload starting from the third iovec.
|
|
|
|
*/
|
2015-01-20 06:28:47 +03:00
|
|
|
ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV;
|
|
|
|
ioctl_req->hdr.iovec_count = elem->out_num - 2;
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2015-01-20 06:28:47 +03:00
|
|
|
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
|
|
|
|
ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len;
|
|
|
|
}
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2015-01-20 06:28:47 +03:00
|
|
|
ioctl_req->hdr.dxferp = elem->out_sg + 2;
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2014-05-22 12:22:42 +04:00
|
|
|
} else if (elem->in_num > 3) {
|
2009-04-27 12:29:14 +04:00
|
|
|
/*
|
|
|
|
* If we have more than 3 input segments the guest wants to actually
|
|
|
|
* read data.
|
|
|
|
*/
|
2015-01-20 06:28:47 +03:00
|
|
|
ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV;
|
|
|
|
ioctl_req->hdr.iovec_count = elem->in_num - 3;
|
|
|
|
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
|
|
|
|
ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len;
|
|
|
|
}
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2015-01-20 06:28:47 +03:00
|
|
|
ioctl_req->hdr.dxferp = elem->in_sg;
|
2009-04-27 12:29:14 +04:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Some SCSI commands don't actually transfer any data.
|
|
|
|
*/
|
2015-01-20 06:28:47 +03:00
|
|
|
ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE;
|
2009-04-27 12:29:14 +04:00
|
|
|
}
|
|
|
|
|
2015-01-20 06:28:47 +03:00
|
|
|
ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base;
|
|
|
|
ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len;
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2015-02-17 12:55:53 +03:00
|
|
|
acb = blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr,
|
|
|
|
virtio_blk_ioctl_complete, ioctl_req);
|
|
|
|
if (!acb) {
|
|
|
|
g_free(ioctl_req);
|
|
|
|
status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-01-20 06:28:47 +03:00
|
|
|
return -EINPROGRESS;
|
2009-04-27 12:29:14 +04:00
|
|
|
#else
|
2012-05-16 14:54:03 +04:00
|
|
|
abort();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
fail:
|
|
|
|
/* Just put anything nonzero so that the ioctl fails in the guest. */
|
2014-05-22 12:22:42 +04:00
|
|
|
if (scsi) {
|
2014-06-24 21:43:44 +04:00
|
|
|
virtio_stl_p(vdev, &scsi->errors, 255);
|
2014-05-22 12:22:42 +04:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
2015-01-20 06:28:46 +03:00
|
|
|
status = virtio_blk_handle_scsi_req(req);
|
2015-01-20 06:28:47 +03:00
|
|
|
if (status != -EINPROGRESS) {
|
|
|
|
virtio_blk_req_complete(req, status);
|
|
|
|
virtio_blk_free_request(req);
|
|
|
|
}
|
2009-04-27 12:29:14 +04:00
|
|
|
}
|
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
static inline void submit_requests(BlockBackend *blk, MultiReqBuffer *mrb,
|
|
|
|
int start, int num_reqs, int niov)
|
2009-01-22 22:52:25 +03:00
|
|
|
{
|
2015-02-02 16:52:21 +03:00
|
|
|
QEMUIOVector *qiov = &mrb->reqs[start]->qiov;
|
|
|
|
int64_t sector_num = mrb->reqs[start]->sector_num;
|
|
|
|
bool is_write = mrb->is_write;
|
|
|
|
|
|
|
|
if (num_reqs > 1) {
|
|
|
|
int i;
|
|
|
|
struct iovec *tmp_iov = qiov->iov;
|
|
|
|
int tmp_niov = qiov->niov;
|
|
|
|
|
|
|
|
/* mrb->reqs[start]->qiov was initialized from external so we can't
|
2016-05-06 19:26:33 +03:00
|
|
|
* modify it here. We need to initialize it locally and then add the
|
2015-02-02 16:52:21 +03:00
|
|
|
* external iovecs. */
|
|
|
|
qemu_iovec_init(qiov, niov);
|
|
|
|
|
|
|
|
for (i = 0; i < tmp_niov; i++) {
|
|
|
|
qemu_iovec_add(qiov, tmp_iov[i].iov_base, tmp_iov[i].iov_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = start + 1; i < start + num_reqs; i++) {
|
|
|
|
qemu_iovec_concat(qiov, &mrb->reqs[i]->qiov, 0,
|
|
|
|
mrb->reqs[i]->qiov.size);
|
|
|
|
mrb->reqs[i - 1]->mr_next = mrb->reqs[i];
|
|
|
|
}
|
|
|
|
|
2017-06-14 12:29:30 +03:00
|
|
|
trace_virtio_blk_submit_multireq(VIRTIO_DEVICE(mrb->reqs[start]->dev),
|
|
|
|
mrb, start, num_reqs,
|
2016-05-06 19:26:33 +03:00
|
|
|
sector_num << BDRV_SECTOR_BITS,
|
|
|
|
qiov->size, is_write);
|
2015-02-02 16:52:21 +03:00
|
|
|
block_acct_merge_done(blk_get_stats(blk),
|
|
|
|
is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ,
|
|
|
|
num_reqs - 1);
|
|
|
|
}
|
2009-09-09 19:53:38 +04:00
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
if (is_write) {
|
2016-05-06 19:26:33 +03:00
|
|
|
blk_aio_pwritev(blk, sector_num << BDRV_SECTOR_BITS, qiov, 0,
|
|
|
|
virtio_blk_rw_complete, mrb->reqs[start]);
|
2015-02-02 16:52:21 +03:00
|
|
|
} else {
|
2016-05-06 19:26:33 +03:00
|
|
|
blk_aio_preadv(blk, sector_num << BDRV_SECTOR_BITS, qiov, 0,
|
|
|
|
virtio_blk_rw_complete, mrb->reqs[start]);
|
2015-02-02 16:52:21 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int multireq_compare(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const VirtIOBlockReq *req1 = *(VirtIOBlockReq **)a,
|
|
|
|
*req2 = *(VirtIOBlockReq **)b;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that we can't simply subtract sector_num1 from sector_num2
|
|
|
|
* here as that could overflow the return value.
|
|
|
|
*/
|
|
|
|
if (req1->sector_num > req2->sector_num) {
|
|
|
|
return 1;
|
|
|
|
} else if (req1->sector_num < req2->sector_num) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-30 18:12:50 +03:00
|
|
|
static void virtio_blk_submit_multireq(BlockBackend *blk, MultiReqBuffer *mrb)
|
2015-02-02 16:52:21 +03:00
|
|
|
{
|
|
|
|
int i = 0, start = 0, num_reqs = 0, niov = 0, nb_sectors = 0;
|
2016-06-24 01:37:19 +03:00
|
|
|
uint32_t max_transfer;
|
2015-02-02 16:52:21 +03:00
|
|
|
int64_t sector_num = 0;
|
|
|
|
|
|
|
|
if (mrb->num_reqs == 1) {
|
|
|
|
submit_requests(blk, mrb, 0, 1, -1);
|
|
|
|
mrb->num_reqs = 0;
|
2010-06-08 20:26:07 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-24 01:37:19 +03:00
|
|
|
max_transfer = blk_get_max_transfer(mrb->reqs[0]->dev->blk);
|
2015-02-02 16:52:21 +03:00
|
|
|
|
|
|
|
qsort(mrb->reqs, mrb->num_reqs, sizeof(*mrb->reqs),
|
|
|
|
&multireq_compare);
|
|
|
|
|
|
|
|
for (i = 0; i < mrb->num_reqs; i++) {
|
|
|
|
VirtIOBlockReq *req = mrb->reqs[i];
|
|
|
|
if (num_reqs > 0) {
|
2015-11-11 04:59:26 +03:00
|
|
|
/*
|
|
|
|
* NOTE: We cannot merge the requests in below situations:
|
|
|
|
* 1. requests are not sequential
|
|
|
|
* 2. merge would exceed maximum number of IOVs
|
|
|
|
* 3. merge would exceed maximum transfer length of backend device
|
|
|
|
*/
|
|
|
|
if (sector_num + nb_sectors != req->sector_num ||
|
2015-07-09 12:56:46 +03:00
|
|
|
niov > blk_get_max_iov(blk) - req->qiov.niov ||
|
2016-06-24 01:37:19 +03:00
|
|
|
req->qiov.size > max_transfer ||
|
|
|
|
nb_sectors > (max_transfer -
|
|
|
|
req->qiov.size) / BDRV_SECTOR_SIZE) {
|
2015-02-02 16:52:21 +03:00
|
|
|
submit_requests(blk, mrb, start, num_reqs, niov);
|
|
|
|
num_reqs = 0;
|
2009-09-09 19:53:38 +04:00
|
|
|
}
|
|
|
|
}
|
2015-02-02 16:52:21 +03:00
|
|
|
|
|
|
|
if (num_reqs == 0) {
|
|
|
|
sector_num = req->sector_num;
|
|
|
|
nb_sectors = niov = 0;
|
|
|
|
start = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
nb_sectors += req->qiov.size / BDRV_SECTOR_SIZE;
|
|
|
|
niov += req->qiov.niov;
|
|
|
|
num_reqs++;
|
2009-09-09 19:53:38 +04:00
|
|
|
}
|
2010-06-08 20:26:07 +04:00
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
submit_requests(blk, mrb, start, num_reqs, niov);
|
|
|
|
mrb->num_reqs = 0;
|
2009-09-09 19:53:38 +04:00
|
|
|
}
|
2009-08-13 18:49:56 +04:00
|
|
|
|
2010-06-08 20:26:07 +04:00
|
|
|
static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb)
|
2009-09-04 21:02:23 +04:00
|
|
|
{
|
2019-03-07 19:19:25 +03:00
|
|
|
VirtIOBlock *s = req->dev;
|
|
|
|
|
|
|
|
block_acct_start(blk_get_stats(s->blk), &req->acct, 0,
|
2014-09-05 17:46:18 +04:00
|
|
|
BLOCK_ACCT_FLUSH);
|
2011-08-25 10:26:01 +04:00
|
|
|
|
2010-05-19 14:40:09 +04:00
|
|
|
/*
|
|
|
|
* Make sure all outstanding writes are posted to the backing device.
|
|
|
|
*/
|
2015-02-02 16:52:21 +03:00
|
|
|
if (mrb->is_write && mrb->num_reqs > 0) {
|
2019-03-07 19:19:25 +03:00
|
|
|
virtio_blk_submit_multireq(s->blk, mrb);
|
2015-02-02 16:52:21 +03:00
|
|
|
}
|
2019-03-07 19:19:25 +03:00
|
|
|
blk_aio_flush(s->blk, virtio_blk_flush_complete, req);
|
2009-09-04 21:02:23 +04:00
|
|
|
}
|
|
|
|
|
2014-07-09 21:07:29 +04:00
|
|
|
static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
|
|
|
|
uint64_t sector, size_t size)
|
|
|
|
{
|
2014-07-09 21:07:31 +04:00
|
|
|
uint64_t nb_sectors = size >> BDRV_SECTOR_BITS;
|
|
|
|
uint64_t total_sectors;
|
|
|
|
|
2015-02-06 13:54:11 +03:00
|
|
|
if (nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
|
2015-02-02 16:52:21 +03:00
|
|
|
return false;
|
|
|
|
}
|
2014-07-09 21:07:29 +04:00
|
|
|
if (sector & dev->sector_mask) {
|
|
|
|
return false;
|
|
|
|
}
|
2014-10-07 15:59:17 +04:00
|
|
|
if (size % dev->conf.conf.logical_block_size) {
|
2014-07-09 21:07:29 +04:00
|
|
|
return false;
|
|
|
|
}
|
2014-10-07 15:59:18 +04:00
|
|
|
blk_get_geometry(dev->blk, &total_sectors);
|
2014-07-09 21:07:31 +04:00
|
|
|
if (sector > total_sectors || nb_sectors > total_sectors - sector) {
|
|
|
|
return false;
|
|
|
|
}
|
2014-07-09 21:07:29 +04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-02-21 13:33:10 +03:00
|
|
|
static uint8_t virtio_blk_handle_discard_write_zeroes(VirtIOBlockReq *req,
|
|
|
|
struct virtio_blk_discard_write_zeroes *dwz_hdr, bool is_write_zeroes)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = req->dev;
|
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
|
|
|
uint64_t sector;
|
|
|
|
uint32_t num_sectors, flags, max_sectors;
|
|
|
|
uint8_t err_status;
|
|
|
|
int bytes;
|
|
|
|
|
|
|
|
sector = virtio_ldq_p(vdev, &dwz_hdr->sector);
|
|
|
|
num_sectors = virtio_ldl_p(vdev, &dwz_hdr->num_sectors);
|
|
|
|
flags = virtio_ldl_p(vdev, &dwz_hdr->flags);
|
|
|
|
max_sectors = is_write_zeroes ? s->conf.max_write_zeroes_sectors :
|
|
|
|
s->conf.max_discard_sectors;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* max_sectors is at most BDRV_REQUEST_MAX_SECTORS, this check
|
|
|
|
* make us sure that "num_sectors << BDRV_SECTOR_BITS" can fit in
|
|
|
|
* the integer variable.
|
|
|
|
*/
|
|
|
|
if (unlikely(num_sectors > max_sectors)) {
|
|
|
|
err_status = VIRTIO_BLK_S_IOERR;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
bytes = num_sectors << BDRV_SECTOR_BITS;
|
|
|
|
|
|
|
|
if (unlikely(!virtio_blk_sect_range_ok(s, sector, bytes))) {
|
|
|
|
err_status = VIRTIO_BLK_S_IOERR;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for discard
|
|
|
|
* and write zeroes commands if any unknown flag is set.
|
|
|
|
*/
|
|
|
|
if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
|
|
|
|
err_status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_write_zeroes) { /* VIRTIO_BLK_T_WRITE_ZEROES */
|
|
|
|
int blk_aio_flags = 0;
|
|
|
|
|
|
|
|
if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) {
|
|
|
|
blk_aio_flags |= BDRV_REQ_MAY_UNMAP;
|
|
|
|
}
|
|
|
|
|
|
|
|
block_acct_start(blk_get_stats(s->blk), &req->acct, bytes,
|
|
|
|
BLOCK_ACCT_WRITE);
|
|
|
|
|
|
|
|
blk_aio_pwrite_zeroes(s->blk, sector << BDRV_SECTOR_BITS,
|
|
|
|
bytes, blk_aio_flags,
|
|
|
|
virtio_blk_discard_write_zeroes_complete, req);
|
|
|
|
} else { /* VIRTIO_BLK_T_DISCARD */
|
|
|
|
/*
|
|
|
|
* The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for
|
|
|
|
* discard commands if the unmap flag is set.
|
|
|
|
*/
|
|
|
|
if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
|
|
|
|
err_status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
blk_aio_pdiscard(s->blk, sector << BDRV_SECTOR_BITS, bytes,
|
|
|
|
virtio_blk_discard_write_zeroes_complete, req);
|
|
|
|
}
|
|
|
|
|
|
|
|
return VIRTIO_BLK_S_OK;
|
|
|
|
|
|
|
|
err:
|
|
|
|
if (is_write_zeroes) {
|
|
|
|
block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_WRITE);
|
|
|
|
}
|
|
|
|
return err_status;
|
|
|
|
}
|
|
|
|
|
2016-09-30 18:13:07 +03:00
|
|
|
static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
|
2010-01-27 15:12:34 +03:00
|
|
|
{
|
2011-01-25 13:55:14 +03:00
|
|
|
uint32_t type;
|
2014-07-09 12:05:49 +04:00
|
|
|
struct iovec *in_iov = req->elem.in_sg;
|
2018-11-06 19:09:16 +03:00
|
|
|
struct iovec *out_iov = req->elem.out_sg;
|
2014-07-09 12:05:49 +04:00
|
|
|
unsigned in_num = req->elem.in_num;
|
|
|
|
unsigned out_num = req->elem.out_num;
|
2016-09-30 18:13:07 +03:00
|
|
|
VirtIOBlock *s = req->dev;
|
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
2011-01-25 13:55:14 +03:00
|
|
|
|
2014-07-09 12:05:49 +04:00
|
|
|
if (req->elem.out_num < 1 || req->elem.in_num < 1) {
|
2016-09-30 18:13:07 +03:00
|
|
|
virtio_error(vdev, "virtio-blk missing headers");
|
|
|
|
return -1;
|
2010-01-27 15:12:34 +03:00
|
|
|
}
|
|
|
|
|
2018-11-06 19:09:16 +03:00
|
|
|
if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
|
2014-06-11 08:11:48 +04:00
|
|
|
sizeof(req->out)) != sizeof(req->out))) {
|
2016-09-30 18:13:07 +03:00
|
|
|
virtio_error(vdev, "virtio-blk request outhdr too short");
|
|
|
|
return -1;
|
2014-06-11 08:11:48 +04:00
|
|
|
}
|
2014-06-11 08:11:50 +04:00
|
|
|
|
2018-11-06 19:09:16 +03:00
|
|
|
iov_discard_front(&out_iov, &out_num, sizeof(req->out));
|
2014-06-11 08:11:50 +04:00
|
|
|
|
2015-06-24 12:29:24 +03:00
|
|
|
if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
|
2016-09-30 18:13:07 +03:00
|
|
|
virtio_error(vdev, "virtio-blk request inhdr too short");
|
|
|
|
return -1;
|
2014-06-11 08:11:50 +04:00
|
|
|
}
|
|
|
|
|
2015-04-02 20:50:44 +03:00
|
|
|
/* We always touch the last byte, so just see how big in_iov is. */
|
|
|
|
req->in_len = iov_size(in_iov, in_num);
|
2014-06-11 08:11:50 +04:00
|
|
|
req->in = (void *)in_iov[in_num - 1].iov_base
|
|
|
|
+ in_iov[in_num - 1].iov_len
|
|
|
|
- sizeof(struct virtio_blk_inhdr);
|
|
|
|
iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
|
2010-01-27 15:12:34 +03:00
|
|
|
|
2019-02-08 17:23:47 +03:00
|
|
|
type = virtio_ldl_p(vdev, &req->out.type);
|
2011-01-25 13:55:14 +03:00
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
/* VIRTIO_BLK_T_OUT defines the command direction. VIRTIO_BLK_T_BARRIER
|
2015-04-09 21:32:39 +03:00
|
|
|
* is an optional flag. Although a guest should not send this flag if
|
2015-02-02 16:52:21 +03:00
|
|
|
* not negotiated we ignored it in the past. So keep ignoring it. */
|
|
|
|
switch (type & ~(VIRTIO_BLK_T_OUT | VIRTIO_BLK_T_BARRIER)) {
|
|
|
|
case VIRTIO_BLK_T_IN:
|
|
|
|
{
|
|
|
|
bool is_write = type & VIRTIO_BLK_T_OUT;
|
2019-02-08 17:23:47 +03:00
|
|
|
req->sector_num = virtio_ldq_p(vdev, &req->out.sector);
|
2015-02-02 16:52:21 +03:00
|
|
|
|
|
|
|
if (is_write) {
|
2018-11-06 19:09:16 +03:00
|
|
|
qemu_iovec_init_external(&req->qiov, out_iov, out_num);
|
2017-06-14 12:29:30 +03:00
|
|
|
trace_virtio_blk_handle_write(vdev, req, req->sector_num,
|
2015-02-02 16:52:21 +03:00
|
|
|
req->qiov.size / BDRV_SECTOR_SIZE);
|
|
|
|
} else {
|
|
|
|
qemu_iovec_init_external(&req->qiov, in_iov, in_num);
|
2017-06-14 12:29:30 +03:00
|
|
|
trace_virtio_blk_handle_read(vdev, req, req->sector_num,
|
2015-02-02 16:52:21 +03:00
|
|
|
req->qiov.size / BDRV_SECTOR_SIZE);
|
|
|
|
}
|
|
|
|
|
2019-02-08 17:23:47 +03:00
|
|
|
if (!virtio_blk_sect_range_ok(s, req->sector_num, req->qiov.size)) {
|
2015-02-02 16:52:21 +03:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
|
2019-02-08 17:23:47 +03:00
|
|
|
block_acct_invalid(blk_get_stats(s->blk),
|
2015-10-28 18:33:12 +03:00
|
|
|
is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ);
|
2015-02-02 16:52:21 +03:00
|
|
|
virtio_blk_free_request(req);
|
2016-09-30 18:13:07 +03:00
|
|
|
return 0;
|
2015-02-02 16:52:21 +03:00
|
|
|
}
|
|
|
|
|
2019-02-08 17:23:47 +03:00
|
|
|
block_acct_start(blk_get_stats(s->blk), &req->acct, req->qiov.size,
|
2015-02-02 16:52:21 +03:00
|
|
|
is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ);
|
|
|
|
|
|
|
|
/* merge would exceed maximum number of requests or IO direction
|
|
|
|
* changes */
|
|
|
|
if (mrb->num_reqs > 0 && (mrb->num_reqs == VIRTIO_BLK_MAX_MERGE_REQS ||
|
2015-02-02 16:52:22 +03:00
|
|
|
is_write != mrb->is_write ||
|
2019-02-08 17:23:47 +03:00
|
|
|
!s->conf.request_merging)) {
|
|
|
|
virtio_blk_submit_multireq(s->blk, mrb);
|
2015-02-02 16:52:21 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(mrb->num_reqs < VIRTIO_BLK_MAX_MERGE_REQS);
|
|
|
|
mrb->reqs[mrb->num_reqs++] = req;
|
|
|
|
mrb->is_write = is_write;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case VIRTIO_BLK_T_FLUSH:
|
2010-06-08 20:26:07 +04:00
|
|
|
virtio_blk_handle_flush(req, mrb);
|
2015-02-02 16:52:21 +03:00
|
|
|
break;
|
|
|
|
case VIRTIO_BLK_T_SCSI_CMD:
|
2010-01-27 15:12:34 +03:00
|
|
|
virtio_blk_handle_scsi(req);
|
2015-02-02 16:52:21 +03:00
|
|
|
break;
|
|
|
|
case VIRTIO_BLK_T_GET_ID:
|
|
|
|
{
|
2011-06-20 13:35:18 +04:00
|
|
|
/*
|
|
|
|
* NB: per existing s/n string convention the string is
|
|
|
|
* terminated by '\0' only when shorter than buffer.
|
|
|
|
*/
|
2014-10-07 15:59:17 +04:00
|
|
|
const char *serial = s->conf.serial ? s->conf.serial : "";
|
2014-08-12 15:41:51 +04:00
|
|
|
size_t size = MIN(strlen(serial) + 1,
|
|
|
|
MIN(iov_size(in_iov, in_num),
|
|
|
|
VIRTIO_BLK_ID_BYTES));
|
|
|
|
iov_from_buf(in_iov, in_num, 0, serial, size);
|
2010-07-02 21:44:25 +04:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
|
2014-06-11 08:11:43 +04:00
|
|
|
virtio_blk_free_request(req);
|
2015-02-02 16:52:21 +03:00
|
|
|
break;
|
|
|
|
}
|
2019-02-21 13:33:10 +03:00
|
|
|
/*
|
|
|
|
* VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROES are defined with
|
|
|
|
* VIRTIO_BLK_T_OUT flag set. We masked this flag in the switch statement,
|
|
|
|
* so we must mask it for these requests, then we will check if it is set.
|
|
|
|
*/
|
|
|
|
case VIRTIO_BLK_T_DISCARD & ~VIRTIO_BLK_T_OUT:
|
|
|
|
case VIRTIO_BLK_T_WRITE_ZEROES & ~VIRTIO_BLK_T_OUT:
|
|
|
|
{
|
|
|
|
struct virtio_blk_discard_write_zeroes dwz_hdr;
|
|
|
|
size_t out_len = iov_size(out_iov, out_num);
|
|
|
|
bool is_write_zeroes = (type & ~VIRTIO_BLK_T_BARRIER) ==
|
|
|
|
VIRTIO_BLK_T_WRITE_ZEROES;
|
|
|
|
uint8_t err_status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unsupported if VIRTIO_BLK_T_OUT is not set or the request contains
|
|
|
|
* more than one segment.
|
|
|
|
*/
|
|
|
|
if (unlikely(!(type & VIRTIO_BLK_T_OUT) ||
|
|
|
|
out_len > sizeof(dwz_hdr))) {
|
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
|
|
|
|
virtio_blk_free_request(req);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(iov_to_buf(out_iov, out_num, 0, &dwz_hdr,
|
|
|
|
sizeof(dwz_hdr)) != sizeof(dwz_hdr))) {
|
|
|
|
virtio_error(vdev, "virtio-blk discard/write_zeroes header"
|
|
|
|
" too short");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
err_status = virtio_blk_handle_discard_write_zeroes(req, &dwz_hdr,
|
|
|
|
is_write_zeroes);
|
|
|
|
if (err_status != VIRTIO_BLK_S_OK) {
|
|
|
|
virtio_blk_req_complete(req, err_status);
|
|
|
|
virtio_blk_free_request(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2015-02-02 16:52:21 +03:00
|
|
|
default:
|
2012-12-13 11:03:43 +04:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
|
2014-06-11 08:11:43 +04:00
|
|
|
virtio_blk_free_request(req);
|
2010-01-27 15:12:34 +03:00
|
|
|
}
|
2016-09-30 18:13:07 +03:00
|
|
|
return 0;
|
2010-01-27 15:12:34 +03:00
|
|
|
}
|
|
|
|
|
2017-02-09 11:40:47 +03:00
|
|
|
bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
|
2008-12-04 22:52:44 +03:00
|
|
|
{
|
|
|
|
VirtIOBlockReq *req;
|
2015-02-02 16:52:21 +03:00
|
|
|
MultiReqBuffer mrb = {};
|
2019-12-10 00:09:57 +03:00
|
|
|
bool suppress_notifications = virtio_queue_get_notification(vq);
|
2017-02-09 11:40:47 +03:00
|
|
|
bool progress = false;
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2017-02-13 16:52:30 +03:00
|
|
|
aio_context_acquire(blk_get_aio_context(s->blk));
|
2015-07-20 18:54:16 +03:00
|
|
|
blk_io_plug(s->blk);
|
|
|
|
|
2016-12-01 22:26:46 +03:00
|
|
|
do {
|
2019-12-10 00:09:57 +03:00
|
|
|
if (suppress_notifications) {
|
|
|
|
virtio_queue_set_notification(vq, 0);
|
|
|
|
}
|
2016-12-01 22:26:46 +03:00
|
|
|
|
|
|
|
while ((req = virtio_blk_get_request(s, vq))) {
|
2017-02-09 11:40:47 +03:00
|
|
|
progress = true;
|
2016-12-01 22:26:46 +03:00
|
|
|
if (virtio_blk_handle_request(req, &mrb)) {
|
|
|
|
virtqueue_detach_element(req->vq, &req->elem, 0);
|
|
|
|
virtio_blk_free_request(req);
|
|
|
|
break;
|
|
|
|
}
|
2016-09-30 18:13:07 +03:00
|
|
|
}
|
2016-12-01 22:26:46 +03:00
|
|
|
|
2019-12-10 00:09:57 +03:00
|
|
|
if (suppress_notifications) {
|
|
|
|
virtio_queue_set_notification(vq, 1);
|
|
|
|
}
|
2016-12-01 22:26:46 +03:00
|
|
|
} while (!virtio_queue_empty(vq));
|
2009-09-09 19:53:38 +04:00
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
if (mrb.num_reqs) {
|
|
|
|
virtio_blk_submit_multireq(s->blk, &mrb);
|
|
|
|
}
|
2015-07-20 18:54:16 +03:00
|
|
|
|
|
|
|
blk_io_unplug(s->blk);
|
2017-02-13 16:52:30 +03:00
|
|
|
aio_context_release(blk_get_aio_context(s->blk));
|
2017-02-09 11:40:47 +03:00
|
|
|
return progress;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_blk_handle_output_do(VirtIOBlock *s, VirtQueue *vq)
|
|
|
|
{
|
|
|
|
virtio_blk_handle_vq(s, vq);
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
|
|
|
|
2016-04-06 13:16:26 +03:00
|
|
|
static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = (VirtIOBlock *)vdev;
|
|
|
|
|
|
|
|
if (s->dataplane) {
|
|
|
|
/* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
|
|
|
|
* dataplane here instead of waiting for .set_status().
|
|
|
|
*/
|
virtio-blk: always use dataplane path if ioeventfd is active
Override start_ioeventfd and stop_ioeventfd to start/stop the
whole dataplane logic. This has some positive side effects:
- no need anymore for virtio_add_queue_aio (i.e. a revert of
commit 0ff841f6d138904d514efa1d885bcaf54583852d)
- no need anymore to switch from generic ioeventfd handlers to
dataplane
It detects some errors better:
$ qemu-system-x86_64 -object iothread,id=io \
-drive id=null,file=null-aio://,if=none,format=raw \
-device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null
qemu-system-x86_64: -device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null:
ioeventfd is required for iothread
while previously it would have started just fine.
Reviewed-by: Cornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2016-10-21 23:48:09 +03:00
|
|
|
virtio_device_start_ioeventfd(vdev);
|
2016-04-06 13:16:26 +03:00
|
|
|
if (!s->dataplane_disabled) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2017-02-09 11:40:47 +03:00
|
|
|
virtio_blk_handle_output_do(s, vq);
|
2016-04-06 13:16:26 +03:00
|
|
|
}
|
|
|
|
|
virtio-blk: On restart, process queued requests in the proper context
On restart, we were scheduling a BH to process queued requests, which
would run before starting up the data plane, leading to those requests
being assigned and started on coroutines on the main context.
This could cause requests to be wrongly processed in parallel from
different threads (the main thread and the iothread managing the data
plane), potentially leading to multiple issues.
For example, stopping and resuming a VM multiple times while the guest
is generating I/O on a virtio_blk device can trigger a crash with a
stack tracing looking like this one:
<------>
Thread 2 (Thread 0x7ff736765700 (LWP 1062503)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f43d9 in qemu_laio_process_completions_and_submit (s=0x7ff7182e8420)
at block/linux-aio.c:236
#6 0x00005567a12f44c2 in qemu_laio_poll_cb (opaque=0x7ff7182e8430) at block/linux-aio.c:267
#7 0x00005567a13aed83 in run_poll_handlers_once (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:520
#8 0x00005567a13aee9f in run_poll_handlers (ctx=0x5567a2b58c70, max_ns=16000, timeout=0x7ff7367645f8)
at util/aio-posix.c:562
#9 0x00005567a13aefde in try_poll_mode (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:597
#10 0x00005567a13af115 in aio_poll (ctx=0x5567a2b58c70, blocking=true) at util/aio-posix.c:639
#11 0x00005567a109acca in iothread_run (opaque=0x5567a2b29760) at iothread.c:75
#12 0x00005567a13b2790 in qemu_thread_start (args=0x5567a2b694c0) at util/qemu-thread-posix.c:519
#13 0x00007ff73eedf2de in start_thread () at /lib64/libpthread.so.0
#14 0x00007ff73ec10e83 in clone () at /lib64/libc.so.6
Thread 1 (Thread 0x7ff743986f00 (LWP 1062500)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f4a2f in laio_do_submit (fd=19, laiocb=0x7ff5f4ff9ae0, offset=472363008, type=2)
at block/linux-aio.c:375
#6 0x00005567a12f4af2 in laio_co_submit
(bs=0x5567a2b8c460, s=0x7ff7182e8420, fd=19, offset=472363008, qiov=0x7ff5f4ff9ca0, type=2)
at block/linux-aio.c:394
#7 0x00005567a12f1803 in raw_co_prw
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, type=2)
at block/file-posix.c:1892
#8 0x00005567a12f1941 in raw_co_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, flags=0)
at block/file-posix.c:1925
#9 0x00005567a12fe3e1 in bdrv_driver_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, qiov_offset=0, flags=0)
at block/io.c:1183
#10 0x00005567a1300340 in bdrv_aligned_pwritev
(child=0x5567a2b5b070, req=0x7ff5f4ff9db0, offset=472363008, bytes=20480, align=512, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0) at block/io.c:1980
#11 0x00005567a1300b29 in bdrv_co_pwritev_part
(child=0x5567a2b5b070, offset=472363008, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0)
at block/io.c:2137
#12 0x00005567a12baba1 in qcow2_co_pwritev_task
(bs=0x5567a2b92740, file_cluster_offset=472317952, offset=487305216, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, l2meta=0x0) at block/qcow2.c:2444
#13 0x00005567a12bacdb in qcow2_co_pwritev_task_entry (task=0x5567a2b48540) at block/qcow2.c:2475
#14 0x00005567a13167d8 in aio_task_co (opaque=0x5567a2b48540) at block/aio_task.c:45
#15 0x00005567a13cf00c in coroutine_trampoline (i0=738245600, i1=32759) at util/coroutine-ucontext.c:115
#16 0x00007ff73eb622e0 in __start_context () at /lib64/libc.so.6
#17 0x00007ff6626f1350 in ()
#18 0x0000000000000000 in ()
<------>
This is also known to cause crashes with this message (assertion
failed):
aio_co_schedule: Co-routine was already scheduled in 'aio_co_schedule'
RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1812765
Signed-off-by: Sergio Lopez <slp@redhat.com>
Message-Id: <20200603093240.40489-3-slp@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2020-06-03 12:32:40 +03:00
|
|
|
void virtio_blk_process_queued_requests(VirtIOBlock *s, bool is_bh)
|
2009-01-22 22:52:25 +03:00
|
|
|
{
|
|
|
|
VirtIOBlockReq *req = s->rq;
|
2015-02-02 16:52:21 +03:00
|
|
|
MultiReqBuffer mrb = {};
|
2009-01-22 22:52:25 +03:00
|
|
|
|
|
|
|
s->rq = NULL;
|
|
|
|
|
2017-02-13 16:52:31 +03:00
|
|
|
aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
|
2009-01-22 22:52:25 +03:00
|
|
|
while (req) {
|
2014-08-18 11:42:50 +04:00
|
|
|
VirtIOBlockReq *next = req->next;
|
2016-09-30 18:13:07 +03:00
|
|
|
if (virtio_blk_handle_request(req, &mrb)) {
|
|
|
|
/* Device is now broken and won't do any processing until it gets
|
|
|
|
* reset. Already queued requests will be lost: let's purge them.
|
|
|
|
*/
|
|
|
|
while (req) {
|
|
|
|
next = req->next;
|
|
|
|
virtqueue_detach_element(req->vq, &req->elem, 0);
|
|
|
|
virtio_blk_free_request(req);
|
|
|
|
req = next;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-18 11:42:50 +04:00
|
|
|
req = next;
|
2009-01-22 22:52:25 +03:00
|
|
|
}
|
2010-01-27 15:12:35 +03:00
|
|
|
|
2015-02-02 16:52:21 +03:00
|
|
|
if (mrb.num_reqs) {
|
|
|
|
virtio_blk_submit_multireq(s->blk, &mrb);
|
|
|
|
}
|
virtio-blk: On restart, process queued requests in the proper context
On restart, we were scheduling a BH to process queued requests, which
would run before starting up the data plane, leading to those requests
being assigned and started on coroutines on the main context.
This could cause requests to be wrongly processed in parallel from
different threads (the main thread and the iothread managing the data
plane), potentially leading to multiple issues.
For example, stopping and resuming a VM multiple times while the guest
is generating I/O on a virtio_blk device can trigger a crash with a
stack tracing looking like this one:
<------>
Thread 2 (Thread 0x7ff736765700 (LWP 1062503)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f43d9 in qemu_laio_process_completions_and_submit (s=0x7ff7182e8420)
at block/linux-aio.c:236
#6 0x00005567a12f44c2 in qemu_laio_poll_cb (opaque=0x7ff7182e8430) at block/linux-aio.c:267
#7 0x00005567a13aed83 in run_poll_handlers_once (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:520
#8 0x00005567a13aee9f in run_poll_handlers (ctx=0x5567a2b58c70, max_ns=16000, timeout=0x7ff7367645f8)
at util/aio-posix.c:562
#9 0x00005567a13aefde in try_poll_mode (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:597
#10 0x00005567a13af115 in aio_poll (ctx=0x5567a2b58c70, blocking=true) at util/aio-posix.c:639
#11 0x00005567a109acca in iothread_run (opaque=0x5567a2b29760) at iothread.c:75
#12 0x00005567a13b2790 in qemu_thread_start (args=0x5567a2b694c0) at util/qemu-thread-posix.c:519
#13 0x00007ff73eedf2de in start_thread () at /lib64/libpthread.so.0
#14 0x00007ff73ec10e83 in clone () at /lib64/libc.so.6
Thread 1 (Thread 0x7ff743986f00 (LWP 1062500)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f4a2f in laio_do_submit (fd=19, laiocb=0x7ff5f4ff9ae0, offset=472363008, type=2)
at block/linux-aio.c:375
#6 0x00005567a12f4af2 in laio_co_submit
(bs=0x5567a2b8c460, s=0x7ff7182e8420, fd=19, offset=472363008, qiov=0x7ff5f4ff9ca0, type=2)
at block/linux-aio.c:394
#7 0x00005567a12f1803 in raw_co_prw
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, type=2)
at block/file-posix.c:1892
#8 0x00005567a12f1941 in raw_co_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, flags=0)
at block/file-posix.c:1925
#9 0x00005567a12fe3e1 in bdrv_driver_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, qiov_offset=0, flags=0)
at block/io.c:1183
#10 0x00005567a1300340 in bdrv_aligned_pwritev
(child=0x5567a2b5b070, req=0x7ff5f4ff9db0, offset=472363008, bytes=20480, align=512, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0) at block/io.c:1980
#11 0x00005567a1300b29 in bdrv_co_pwritev_part
(child=0x5567a2b5b070, offset=472363008, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0)
at block/io.c:2137
#12 0x00005567a12baba1 in qcow2_co_pwritev_task
(bs=0x5567a2b92740, file_cluster_offset=472317952, offset=487305216, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, l2meta=0x0) at block/qcow2.c:2444
#13 0x00005567a12bacdb in qcow2_co_pwritev_task_entry (task=0x5567a2b48540) at block/qcow2.c:2475
#14 0x00005567a13167d8 in aio_task_co (opaque=0x5567a2b48540) at block/aio_task.c:45
#15 0x00005567a13cf00c in coroutine_trampoline (i0=738245600, i1=32759) at util/coroutine-ucontext.c:115
#16 0x00007ff73eb622e0 in __start_context () at /lib64/libc.so.6
#17 0x00007ff6626f1350 in ()
#18 0x0000000000000000 in ()
<------>
This is also known to cause crashes with this message (assertion
failed):
aio_co_schedule: Co-routine was already scheduled in 'aio_co_schedule'
RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1812765
Signed-off-by: Sergio Lopez <slp@redhat.com>
Message-Id: <20200603093240.40489-3-slp@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2020-06-03 12:32:40 +03:00
|
|
|
if (is_bh) {
|
|
|
|
blk_dec_in_flight(s->conf.conf.blk);
|
|
|
|
}
|
2017-02-13 16:52:31 +03:00
|
|
|
aio_context_release(blk_get_aio_context(s->conf.conf.blk));
|
2009-01-22 22:52:25 +03:00
|
|
|
}
|
|
|
|
|
2020-06-03 12:32:39 +03:00
|
|
|
static void virtio_blk_dma_restart_bh(void *opaque)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = opaque;
|
|
|
|
|
|
|
|
qemu_bh_delete(s->bh);
|
|
|
|
s->bh = NULL;
|
|
|
|
|
virtio-blk: On restart, process queued requests in the proper context
On restart, we were scheduling a BH to process queued requests, which
would run before starting up the data plane, leading to those requests
being assigned and started on coroutines on the main context.
This could cause requests to be wrongly processed in parallel from
different threads (the main thread and the iothread managing the data
plane), potentially leading to multiple issues.
For example, stopping and resuming a VM multiple times while the guest
is generating I/O on a virtio_blk device can trigger a crash with a
stack tracing looking like this one:
<------>
Thread 2 (Thread 0x7ff736765700 (LWP 1062503)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f43d9 in qemu_laio_process_completions_and_submit (s=0x7ff7182e8420)
at block/linux-aio.c:236
#6 0x00005567a12f44c2 in qemu_laio_poll_cb (opaque=0x7ff7182e8430) at block/linux-aio.c:267
#7 0x00005567a13aed83 in run_poll_handlers_once (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:520
#8 0x00005567a13aee9f in run_poll_handlers (ctx=0x5567a2b58c70, max_ns=16000, timeout=0x7ff7367645f8)
at util/aio-posix.c:562
#9 0x00005567a13aefde in try_poll_mode (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:597
#10 0x00005567a13af115 in aio_poll (ctx=0x5567a2b58c70, blocking=true) at util/aio-posix.c:639
#11 0x00005567a109acca in iothread_run (opaque=0x5567a2b29760) at iothread.c:75
#12 0x00005567a13b2790 in qemu_thread_start (args=0x5567a2b694c0) at util/qemu-thread-posix.c:519
#13 0x00007ff73eedf2de in start_thread () at /lib64/libpthread.so.0
#14 0x00007ff73ec10e83 in clone () at /lib64/libc.so.6
Thread 1 (Thread 0x7ff743986f00 (LWP 1062500)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f4a2f in laio_do_submit (fd=19, laiocb=0x7ff5f4ff9ae0, offset=472363008, type=2)
at block/linux-aio.c:375
#6 0x00005567a12f4af2 in laio_co_submit
(bs=0x5567a2b8c460, s=0x7ff7182e8420, fd=19, offset=472363008, qiov=0x7ff5f4ff9ca0, type=2)
at block/linux-aio.c:394
#7 0x00005567a12f1803 in raw_co_prw
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, type=2)
at block/file-posix.c:1892
#8 0x00005567a12f1941 in raw_co_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, flags=0)
at block/file-posix.c:1925
#9 0x00005567a12fe3e1 in bdrv_driver_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, qiov_offset=0, flags=0)
at block/io.c:1183
#10 0x00005567a1300340 in bdrv_aligned_pwritev
(child=0x5567a2b5b070, req=0x7ff5f4ff9db0, offset=472363008, bytes=20480, align=512, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0) at block/io.c:1980
#11 0x00005567a1300b29 in bdrv_co_pwritev_part
(child=0x5567a2b5b070, offset=472363008, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0)
at block/io.c:2137
#12 0x00005567a12baba1 in qcow2_co_pwritev_task
(bs=0x5567a2b92740, file_cluster_offset=472317952, offset=487305216, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, l2meta=0x0) at block/qcow2.c:2444
#13 0x00005567a12bacdb in qcow2_co_pwritev_task_entry (task=0x5567a2b48540) at block/qcow2.c:2475
#14 0x00005567a13167d8 in aio_task_co (opaque=0x5567a2b48540) at block/aio_task.c:45
#15 0x00005567a13cf00c in coroutine_trampoline (i0=738245600, i1=32759) at util/coroutine-ucontext.c:115
#16 0x00007ff73eb622e0 in __start_context () at /lib64/libc.so.6
#17 0x00007ff6626f1350 in ()
#18 0x0000000000000000 in ()
<------>
This is also known to cause crashes with this message (assertion
failed):
aio_co_schedule: Co-routine was already scheduled in 'aio_co_schedule'
RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1812765
Signed-off-by: Sergio Lopez <slp@redhat.com>
Message-Id: <20200603093240.40489-3-slp@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2020-06-03 12:32:40 +03:00
|
|
|
virtio_blk_process_queued_requests(s, true);
|
2020-06-03 12:32:39 +03:00
|
|
|
}
|
|
|
|
|
2011-07-29 21:26:33 +04:00
|
|
|
static void virtio_blk_dma_restart_cb(void *opaque, int running,
|
|
|
|
RunState state)
|
2009-07-28 22:33:41 +04:00
|
|
|
{
|
|
|
|
VirtIOBlock *s = opaque;
|
virtio-blk: On restart, process queued requests in the proper context
On restart, we were scheduling a BH to process queued requests, which
would run before starting up the data plane, leading to those requests
being assigned and started on coroutines on the main context.
This could cause requests to be wrongly processed in parallel from
different threads (the main thread and the iothread managing the data
plane), potentially leading to multiple issues.
For example, stopping and resuming a VM multiple times while the guest
is generating I/O on a virtio_blk device can trigger a crash with a
stack tracing looking like this one:
<------>
Thread 2 (Thread 0x7ff736765700 (LWP 1062503)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f43d9 in qemu_laio_process_completions_and_submit (s=0x7ff7182e8420)
at block/linux-aio.c:236
#6 0x00005567a12f44c2 in qemu_laio_poll_cb (opaque=0x7ff7182e8430) at block/linux-aio.c:267
#7 0x00005567a13aed83 in run_poll_handlers_once (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:520
#8 0x00005567a13aee9f in run_poll_handlers (ctx=0x5567a2b58c70, max_ns=16000, timeout=0x7ff7367645f8)
at util/aio-posix.c:562
#9 0x00005567a13aefde in try_poll_mode (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:597
#10 0x00005567a13af115 in aio_poll (ctx=0x5567a2b58c70, blocking=true) at util/aio-posix.c:639
#11 0x00005567a109acca in iothread_run (opaque=0x5567a2b29760) at iothread.c:75
#12 0x00005567a13b2790 in qemu_thread_start (args=0x5567a2b694c0) at util/qemu-thread-posix.c:519
#13 0x00007ff73eedf2de in start_thread () at /lib64/libpthread.so.0
#14 0x00007ff73ec10e83 in clone () at /lib64/libc.so.6
Thread 1 (Thread 0x7ff743986f00 (LWP 1062500)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f4a2f in laio_do_submit (fd=19, laiocb=0x7ff5f4ff9ae0, offset=472363008, type=2)
at block/linux-aio.c:375
#6 0x00005567a12f4af2 in laio_co_submit
(bs=0x5567a2b8c460, s=0x7ff7182e8420, fd=19, offset=472363008, qiov=0x7ff5f4ff9ca0, type=2)
at block/linux-aio.c:394
#7 0x00005567a12f1803 in raw_co_prw
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, type=2)
at block/file-posix.c:1892
#8 0x00005567a12f1941 in raw_co_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, flags=0)
at block/file-posix.c:1925
#9 0x00005567a12fe3e1 in bdrv_driver_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, qiov_offset=0, flags=0)
at block/io.c:1183
#10 0x00005567a1300340 in bdrv_aligned_pwritev
(child=0x5567a2b5b070, req=0x7ff5f4ff9db0, offset=472363008, bytes=20480, align=512, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0) at block/io.c:1980
#11 0x00005567a1300b29 in bdrv_co_pwritev_part
(child=0x5567a2b5b070, offset=472363008, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0)
at block/io.c:2137
#12 0x00005567a12baba1 in qcow2_co_pwritev_task
(bs=0x5567a2b92740, file_cluster_offset=472317952, offset=487305216, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, l2meta=0x0) at block/qcow2.c:2444
#13 0x00005567a12bacdb in qcow2_co_pwritev_task_entry (task=0x5567a2b48540) at block/qcow2.c:2475
#14 0x00005567a13167d8 in aio_task_co (opaque=0x5567a2b48540) at block/aio_task.c:45
#15 0x00005567a13cf00c in coroutine_trampoline (i0=738245600, i1=32759) at util/coroutine-ucontext.c:115
#16 0x00007ff73eb622e0 in __start_context () at /lib64/libc.so.6
#17 0x00007ff6626f1350 in ()
#18 0x0000000000000000 in ()
<------>
This is also known to cause crashes with this message (assertion
failed):
aio_co_schedule: Co-routine was already scheduled in 'aio_co_schedule'
RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1812765
Signed-off-by: Sergio Lopez <slp@redhat.com>
Message-Id: <20200603093240.40489-3-slp@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2020-06-03 12:32:40 +03:00
|
|
|
BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
|
|
|
|
VirtioBusState *bus = VIRTIO_BUS(qbus);
|
2009-07-28 22:33:41 +04:00
|
|
|
|
2012-11-14 18:45:38 +04:00
|
|
|
if (!running) {
|
2009-07-28 22:33:41 +04:00
|
|
|
return;
|
2012-11-14 18:45:38 +04:00
|
|
|
}
|
2009-07-28 22:33:41 +04:00
|
|
|
|
virtio-blk: On restart, process queued requests in the proper context
On restart, we were scheduling a BH to process queued requests, which
would run before starting up the data plane, leading to those requests
being assigned and started on coroutines on the main context.
This could cause requests to be wrongly processed in parallel from
different threads (the main thread and the iothread managing the data
plane), potentially leading to multiple issues.
For example, stopping and resuming a VM multiple times while the guest
is generating I/O on a virtio_blk device can trigger a crash with a
stack tracing looking like this one:
<------>
Thread 2 (Thread 0x7ff736765700 (LWP 1062503)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f43d9 in qemu_laio_process_completions_and_submit (s=0x7ff7182e8420)
at block/linux-aio.c:236
#6 0x00005567a12f44c2 in qemu_laio_poll_cb (opaque=0x7ff7182e8430) at block/linux-aio.c:267
#7 0x00005567a13aed83 in run_poll_handlers_once (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:520
#8 0x00005567a13aee9f in run_poll_handlers (ctx=0x5567a2b58c70, max_ns=16000, timeout=0x7ff7367645f8)
at util/aio-posix.c:562
#9 0x00005567a13aefde in try_poll_mode (ctx=0x5567a2b58c70, timeout=0x7ff7367645f8)
at util/aio-posix.c:597
#10 0x00005567a13af115 in aio_poll (ctx=0x5567a2b58c70, blocking=true) at util/aio-posix.c:639
#11 0x00005567a109acca in iothread_run (opaque=0x5567a2b29760) at iothread.c:75
#12 0x00005567a13b2790 in qemu_thread_start (args=0x5567a2b694c0) at util/qemu-thread-posix.c:519
#13 0x00007ff73eedf2de in start_thread () at /lib64/libpthread.so.0
#14 0x00007ff73ec10e83 in clone () at /lib64/libc.so.6
Thread 1 (Thread 0x7ff743986f00 (LWP 1062500)):
#0 0x00005567a13b99d6 in iov_memset
(iov=0x6563617073206f4e, iov_cnt=1717922848, offset=516096, fillc=0, bytes=7018105756081554803)
at util/iov.c:69
#1 0x00005567a13bab73 in qemu_iovec_memset
(qiov=0x7ff73ec99748, offset=516096, fillc=0, bytes=7018105756081554803) at util/iov.c:530
#2 0x00005567a12f411c in qemu_laio_process_completion (laiocb=0x7ff6512ee6c0) at block/linux-aio.c:86
#3 0x00005567a12f42ff in qemu_laio_process_completions (s=0x7ff7182e8420) at block/linux-aio.c:217
#4 0x00005567a12f480d in ioq_submit (s=0x7ff7182e8420) at block/linux-aio.c:323
#5 0x00005567a12f4a2f in laio_do_submit (fd=19, laiocb=0x7ff5f4ff9ae0, offset=472363008, type=2)
at block/linux-aio.c:375
#6 0x00005567a12f4af2 in laio_co_submit
(bs=0x5567a2b8c460, s=0x7ff7182e8420, fd=19, offset=472363008, qiov=0x7ff5f4ff9ca0, type=2)
at block/linux-aio.c:394
#7 0x00005567a12f1803 in raw_co_prw
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, type=2)
at block/file-posix.c:1892
#8 0x00005567a12f1941 in raw_co_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, flags=0)
at block/file-posix.c:1925
#9 0x00005567a12fe3e1 in bdrv_driver_pwritev
(bs=0x5567a2b8c460, offset=472363008, bytes=20480, qiov=0x7ff5f4ff9ca0, qiov_offset=0, flags=0)
at block/io.c:1183
#10 0x00005567a1300340 in bdrv_aligned_pwritev
(child=0x5567a2b5b070, req=0x7ff5f4ff9db0, offset=472363008, bytes=20480, align=512, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0) at block/io.c:1980
#11 0x00005567a1300b29 in bdrv_co_pwritev_part
(child=0x5567a2b5b070, offset=472363008, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, flags=0)
at block/io.c:2137
#12 0x00005567a12baba1 in qcow2_co_pwritev_task
(bs=0x5567a2b92740, file_cluster_offset=472317952, offset=487305216, bytes=20480, qiov=0x7ff72c0425b8, qiov_offset=0, l2meta=0x0) at block/qcow2.c:2444
#13 0x00005567a12bacdb in qcow2_co_pwritev_task_entry (task=0x5567a2b48540) at block/qcow2.c:2475
#14 0x00005567a13167d8 in aio_task_co (opaque=0x5567a2b48540) at block/aio_task.c:45
#15 0x00005567a13cf00c in coroutine_trampoline (i0=738245600, i1=32759) at util/coroutine-ucontext.c:115
#16 0x00007ff73eb622e0 in __start_context () at /lib64/libc.so.6
#17 0x00007ff6626f1350 in ()
#18 0x0000000000000000 in ()
<------>
This is also known to cause crashes with this message (assertion
failed):
aio_co_schedule: Co-routine was already scheduled in 'aio_co_schedule'
RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1812765
Signed-off-by: Sergio Lopez <slp@redhat.com>
Message-Id: <20200603093240.40489-3-slp@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2020-06-03 12:32:40 +03:00
|
|
|
/*
|
|
|
|
* If ioeventfd is enabled, don't schedule the BH here as queued
|
|
|
|
* requests will be processed while starting the data plane.
|
|
|
|
*/
|
|
|
|
if (!s->bh && !virtio_bus_ioeventfd_enabled(bus)) {
|
2014-10-07 15:59:18 +04:00
|
|
|
s->bh = aio_bh_new(blk_get_aio_context(s->conf.conf.blk),
|
2014-06-17 10:32:08 +04:00
|
|
|
virtio_blk_dma_restart_bh, s);
|
2019-02-14 20:51:03 +03:00
|
|
|
blk_inc_in_flight(s->conf.conf.blk);
|
2009-07-28 22:33:41 +04:00
|
|
|
qemu_bh_schedule(s->bh);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-04 22:52:44 +03:00
|
|
|
static void virtio_blk_reset(VirtIODevice *vdev)
|
|
|
|
{
|
2013-03-18 20:37:27 +04:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2015-06-17 13:37:20 +03:00
|
|
|
AioContext *ctx;
|
2016-08-04 05:44:13 +03:00
|
|
|
VirtIOBlockReq *req;
|
2012-11-14 18:45:38 +04:00
|
|
|
|
2015-06-17 13:37:20 +03:00
|
|
|
ctx = blk_get_aio_context(s->blk);
|
|
|
|
aio_context_acquire(ctx);
|
|
|
|
blk_drain(s->blk);
|
|
|
|
|
2016-08-04 05:44:13 +03:00
|
|
|
/* We drop queued requests after blk_drain() because blk_drain() itself can
|
|
|
|
* produce them. */
|
|
|
|
while (s->rq) {
|
|
|
|
req = s->rq;
|
|
|
|
s->rq = req->next;
|
2016-09-19 16:28:04 +03:00
|
|
|
virtqueue_detach_element(req->vq, &req->elem, 0);
|
2016-08-04 05:44:13 +03:00
|
|
|
virtio_blk_free_request(req);
|
|
|
|
}
|
|
|
|
|
2015-06-17 13:37:20 +03:00
|
|
|
aio_context_release(ctx);
|
|
|
|
|
virtio-blk: always use dataplane path if ioeventfd is active
Override start_ioeventfd and stop_ioeventfd to start/stop the
whole dataplane logic. This has some positive side effects:
- no need anymore for virtio_add_queue_aio (i.e. a revert of
commit 0ff841f6d138904d514efa1d885bcaf54583852d)
- no need anymore to switch from generic ioeventfd handlers to
dataplane
It detects some errors better:
$ qemu-system-x86_64 -object iothread,id=io \
-drive id=null,file=null-aio://,if=none,format=raw \
-device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null
qemu-system-x86_64: -device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null:
ioeventfd is required for iothread
while previously it would have started just fine.
Reviewed-by: Cornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2016-10-21 23:48:09 +03:00
|
|
|
assert(!s->dataplane_started);
|
2014-10-07 15:59:18 +04:00
|
|
|
blk_set_enable_write_cache(s->blk, s->original_wce);
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
|
|
|
|
2009-06-22 22:26:51 +04:00
|
|
|
/* coalesce internal state, copy to pci i/o region 0
|
|
|
|
*/
|
2008-12-04 22:52:44 +03:00
|
|
|
static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
|
|
|
|
{
|
2013-03-18 20:37:27 +04:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2014-10-07 15:59:17 +04:00
|
|
|
BlockConf *conf = &s->conf.conf;
|
2008-12-04 22:52:44 +03:00
|
|
|
struct virtio_blk_config blkcfg;
|
|
|
|
uint64_t capacity;
|
2017-08-08 15:22:51 +03:00
|
|
|
int64_t length;
|
2014-10-07 15:59:16 +04:00
|
|
|
int blk_size = conf->logical_block_size;
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
blk_get_geometry(s->blk, &capacity);
|
2009-06-12 11:50:18 +04:00
|
|
|
memset(&blkcfg, 0, sizeof(blkcfg));
|
2014-06-24 21:43:44 +04:00
|
|
|
virtio_stq_p(vdev, &blkcfg.capacity, capacity);
|
2019-12-20 17:09:04 +03:00
|
|
|
virtio_stl_p(vdev, &blkcfg.seg_max,
|
|
|
|
s->conf.seg_max_adjust ? s->conf.queue_size - 2 : 128 - 2);
|
2015-02-17 00:36:03 +03:00
|
|
|
virtio_stw_p(vdev, &blkcfg.geometry.cylinders, conf->cyls);
|
2014-06-24 21:43:44 +04:00
|
|
|
virtio_stl_p(vdev, &blkcfg.blk_size, blk_size);
|
2014-10-07 15:59:16 +04:00
|
|
|
virtio_stw_p(vdev, &blkcfg.min_io_size, conf->min_io_size / blk_size);
|
2020-05-29 01:55:09 +03:00
|
|
|
virtio_stl_p(vdev, &blkcfg.opt_io_size, conf->opt_io_size / blk_size);
|
2015-02-17 00:36:03 +03:00
|
|
|
blkcfg.geometry.heads = conf->heads;
|
2012-05-24 15:22:55 +04:00
|
|
|
/*
|
|
|
|
* We must ensure that the block device capacity is a multiple of
|
2013-04-09 15:48:19 +04:00
|
|
|
* the logical block size. If that is not the case, let's use
|
2012-05-24 15:22:55 +04:00
|
|
|
* sector_mask to adopt the geometry to have a correct picture.
|
|
|
|
* For those devices where the capacity is ok for the given geometry
|
2013-04-09 15:48:19 +04:00
|
|
|
* we don't touch the sector value of the geometry, since some devices
|
2012-05-24 15:22:55 +04:00
|
|
|
* (like s390 dasd) need a specific value. Here the capacity is already
|
|
|
|
* cyls*heads*secs*blk_size and the sector value is not block size
|
|
|
|
* divided by 512 - instead it is the amount of blk_size blocks
|
|
|
|
* per track (cylinder).
|
|
|
|
*/
|
2017-08-08 15:22:51 +03:00
|
|
|
length = blk_getlength(s->blk);
|
|
|
|
if (length > 0 && length / conf->heads / conf->secs % blk_size) {
|
2015-02-17 00:36:03 +03:00
|
|
|
blkcfg.geometry.sectors = conf->secs & ~s->sector_mask;
|
2012-05-24 15:22:55 +04:00
|
|
|
} else {
|
2015-02-17 00:36:03 +03:00
|
|
|
blkcfg.geometry.sectors = conf->secs;
|
2012-05-24 15:22:55 +04:00
|
|
|
}
|
2009-06-13 17:20:25 +04:00
|
|
|
blkcfg.size_max = 0;
|
2014-10-07 15:59:16 +04:00
|
|
|
blkcfg.physical_block_exp = get_physical_block_exp(conf);
|
2010-02-11 01:37:25 +03:00
|
|
|
blkcfg.alignment_offset = 0;
|
2014-10-07 15:59:18 +04:00
|
|
|
blkcfg.wce = blk_enable_write_cache(s->blk);
|
2016-06-21 15:13:16 +03:00
|
|
|
virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues);
|
2019-02-21 13:33:10 +03:00
|
|
|
if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD)) {
|
|
|
|
virtio_stl_p(vdev, &blkcfg.max_discard_sectors,
|
|
|
|
s->conf.max_discard_sectors);
|
|
|
|
virtio_stl_p(vdev, &blkcfg.discard_sector_alignment,
|
|
|
|
blk_size >> BDRV_SECTOR_BITS);
|
|
|
|
/*
|
|
|
|
* We support only one segment per request since multiple segments
|
|
|
|
* are not widely used and there are no userspace APIs that allow
|
|
|
|
* applications to submit multiple segments in a single call.
|
|
|
|
*/
|
|
|
|
virtio_stl_p(vdev, &blkcfg.max_discard_seg, 1);
|
|
|
|
}
|
|
|
|
if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES)) {
|
|
|
|
virtio_stl_p(vdev, &blkcfg.max_write_zeroes_sectors,
|
|
|
|
s->conf.max_write_zeroes_sectors);
|
|
|
|
blkcfg.write_zeroes_may_unmap = 1;
|
|
|
|
virtio_stl_p(vdev, &blkcfg.max_write_zeroes_seg, 1);
|
|
|
|
}
|
2019-02-21 13:33:09 +03:00
|
|
|
memcpy(config, &blkcfg, s->config_size);
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
|
|
|
|
2012-08-09 18:07:19 +04:00
|
|
|
static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
|
|
|
|
{
|
2013-03-18 20:37:27 +04:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2012-08-09 18:07:19 +04:00
|
|
|
struct virtio_blk_config blkcfg;
|
|
|
|
|
2019-02-21 13:33:09 +03:00
|
|
|
memcpy(&blkcfg, config, s->config_size);
|
2014-05-15 15:22:06 +04:00
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
aio_context_acquire(blk_get_aio_context(s->blk));
|
|
|
|
blk_set_enable_write_cache(s->blk, blkcfg.wce != 0);
|
|
|
|
aio_context_release(blk_get_aio_context(s->blk));
|
2012-08-09 18:07:19 +04:00
|
|
|
}
|
|
|
|
|
2015-07-27 12:49:19 +03:00
|
|
|
static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features,
|
|
|
|
Error **errp)
|
2008-12-04 22:52:44 +03:00
|
|
|
{
|
2013-03-18 20:37:27 +04:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2009-04-27 12:29:14 +04:00
|
|
|
|
2019-02-21 13:33:06 +03:00
|
|
|
/* Firstly sync all virtio-blk possible supported features */
|
|
|
|
features |= s->host_features;
|
|
|
|
|
2014-12-11 16:25:05 +03:00
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
|
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
|
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
|
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
|
2015-08-17 12:48:29 +03:00
|
|
|
if (virtio_has_feature(features, VIRTIO_F_VERSION_1)) {
|
2019-02-21 13:33:06 +03:00
|
|
|
if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_SCSI)) {
|
2015-07-27 12:49:20 +03:00
|
|
|
error_setg(errp, "Please set scsi=off for virtio-blk devices in order to use virtio 1.0");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else {
|
2015-07-27 12:49:21 +03:00
|
|
|
virtio_clear_feature(&features, VIRTIO_F_ANY_LAYOUT);
|
2015-07-27 12:49:20 +03:00
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_SCSI);
|
|
|
|
}
|
2009-09-04 21:02:23 +04:00
|
|
|
|
2019-11-05 21:22:17 +03:00
|
|
|
if (blk_enable_write_cache(s->blk) ||
|
|
|
|
(s->conf.x_enable_wce_if_config_wce &&
|
|
|
|
virtio_has_feature(features, VIRTIO_BLK_F_CONFIG_WCE))) {
|
2014-12-11 16:25:05 +03:00
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_WCE);
|
2014-10-07 15:59:18 +04:00
|
|
|
}
|
|
|
|
if (blk_is_read_only(s->blk)) {
|
2014-12-11 16:25:05 +03:00
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_RO);
|
2014-10-07 15:59:18 +04:00
|
|
|
}
|
2016-06-21 15:13:16 +03:00
|
|
|
if (s->conf.num_queues > 1) {
|
|
|
|
virtio_add_feature(&features, VIRTIO_BLK_F_MQ);
|
|
|
|
}
|
2009-04-27 12:29:14 +04:00
|
|
|
|
|
|
|
return features;
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
|
|
|
|
2012-08-09 18:07:20 +04:00
|
|
|
static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status)
|
|
|
|
{
|
2013-03-18 20:37:27 +04:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2012-08-09 18:07:20 +04:00
|
|
|
|
virtio-blk: always use dataplane path if ioeventfd is active
Override start_ioeventfd and stop_ioeventfd to start/stop the
whole dataplane logic. This has some positive side effects:
- no need anymore for virtio_add_queue_aio (i.e. a revert of
commit 0ff841f6d138904d514efa1d885bcaf54583852d)
- no need anymore to switch from generic ioeventfd handlers to
dataplane
It detects some errors better:
$ qemu-system-x86_64 -object iothread,id=io \
-drive id=null,file=null-aio://,if=none,format=raw \
-device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null
qemu-system-x86_64: -device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null:
ioeventfd is required for iothread
while previously it would have started just fine.
Reviewed-by: Cornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2016-10-21 23:48:09 +03:00
|
|
|
if (!(status & (VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_DRIVER_OK))) {
|
|
|
|
assert(!s->dataplane_started);
|
2012-11-14 18:45:38 +04:00
|
|
|
}
|
|
|
|
|
2012-08-09 18:07:20 +04:00
|
|
|
if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
virtio-blk: do not relay a previous driver's WCE configuration to the current
The following sequence happens:
- the SeaBIOS virtio-blk driver does not support the WCE feature, which
causes QEMU to disable writeback caching
- the Linux virtio-blk driver resets the device, finds WCE is available
but writeback caching is disabled; tells block layer to not send cache
flush commands
- the Linux virtio-blk driver sets the DRIVER_OK bit, which causes
writeback caching to be re-enabled, but the Linux virtio-blk driver does
not know of this side effect and cache flushes remain disabled
The bug is at the third step. If the guest does know about CONFIG_WCE,
QEMU should ignore the WCE feature's state. The guest will control the
cache mode solely using configuration space. This change makes Linux
do flushes correctly, but Linux will keep SeaBIOS's writethrough mode.
Hence, whenever the guest is reset, the cache mode of the disk should
be reset to whatever was specified in the "-drive" option. With this
change, the Linux virtio-blk driver finds that writeback caching is
enabled, and tells the block layer to send cache flush commands
appropriately.
Reported-by: Rusty Russell <rusty@au1.ibm.com
Cc: qemu-stable@nongnu.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-09-20 19:31:55 +04:00
|
|
|
/* A guest that supports VIRTIO_BLK_F_CONFIG_WCE must be able to send
|
|
|
|
* cache flushes. Thus, the "auto writethrough" behavior is never
|
|
|
|
* necessary for guests that support the VIRTIO_BLK_F_CONFIG_WCE feature.
|
|
|
|
* Leaving it enabled would break the following sequence:
|
|
|
|
*
|
|
|
|
* Guest started with "-drive cache=writethrough"
|
|
|
|
* Guest sets status to 0
|
|
|
|
* Guest sets DRIVER bit in status field
|
|
|
|
* Guest reads host features (WCE=0, CONFIG_WCE=1)
|
|
|
|
* Guest writes guest features (WCE=0, CONFIG_WCE=1)
|
|
|
|
* Guest writes 1 to the WCE configuration field (writeback mode)
|
|
|
|
* Guest sets DRIVER_OK bit in status field
|
|
|
|
*
|
2014-10-07 15:59:18 +04:00
|
|
|
* s->blk would erroneously be placed in writethrough mode.
|
virtio-blk: do not relay a previous driver's WCE configuration to the current
The following sequence happens:
- the SeaBIOS virtio-blk driver does not support the WCE feature, which
causes QEMU to disable writeback caching
- the Linux virtio-blk driver resets the device, finds WCE is available
but writeback caching is disabled; tells block layer to not send cache
flush commands
- the Linux virtio-blk driver sets the DRIVER_OK bit, which causes
writeback caching to be re-enabled, but the Linux virtio-blk driver does
not know of this side effect and cache flushes remain disabled
The bug is at the third step. If the guest does know about CONFIG_WCE,
QEMU should ignore the WCE feature's state. The guest will control the
cache mode solely using configuration space. This change makes Linux
do flushes correctly, but Linux will keep SeaBIOS's writethrough mode.
Hence, whenever the guest is reset, the cache mode of the disk should
be reset to whatever was specified in the "-drive" option. With this
change, the Linux virtio-blk driver finds that writeback caching is
enabled, and tells the block layer to send cache flush commands
appropriately.
Reported-by: Rusty Russell <rusty@au1.ibm.com
Cc: qemu-stable@nongnu.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-09-20 19:31:55 +04:00
|
|
|
*/
|
2015-08-17 12:48:29 +03:00
|
|
|
if (!virtio_vdev_has_feature(vdev, VIRTIO_BLK_F_CONFIG_WCE)) {
|
2014-10-07 15:59:18 +04:00
|
|
|
aio_context_acquire(blk_get_aio_context(s->blk));
|
|
|
|
blk_set_enable_write_cache(s->blk,
|
2015-08-17 12:48:29 +03:00
|
|
|
virtio_vdev_has_feature(vdev,
|
|
|
|
VIRTIO_BLK_F_WCE));
|
2014-10-07 15:59:18 +04:00
|
|
|
aio_context_release(blk_get_aio_context(s->blk));
|
virtio-blk: do not relay a previous driver's WCE configuration to the current
The following sequence happens:
- the SeaBIOS virtio-blk driver does not support the WCE feature, which
causes QEMU to disable writeback caching
- the Linux virtio-blk driver resets the device, finds WCE is available
but writeback caching is disabled; tells block layer to not send cache
flush commands
- the Linux virtio-blk driver sets the DRIVER_OK bit, which causes
writeback caching to be re-enabled, but the Linux virtio-blk driver does
not know of this side effect and cache flushes remain disabled
The bug is at the third step. If the guest does know about CONFIG_WCE,
QEMU should ignore the WCE feature's state. The guest will control the
cache mode solely using configuration space. This change makes Linux
do flushes correctly, but Linux will keep SeaBIOS's writethrough mode.
Hence, whenever the guest is reset, the cache mode of the disk should
be reset to whatever was specified in the "-drive" option. With this
change, the Linux virtio-blk driver finds that writeback caching is
enabled, and tells the block layer to send cache flush commands
appropriately.
Reported-by: Rusty Russell <rusty@au1.ibm.com
Cc: qemu-stable@nongnu.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-09-20 19:31:55 +04:00
|
|
|
}
|
2012-08-09 18:07:20 +04:00
|
|
|
}
|
|
|
|
|
2014-06-24 21:19:23 +04:00
|
|
|
static void virtio_blk_save_device(VirtIODevice *vdev, QEMUFile *f)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
|
|
|
VirtIOBlockReq *req = s->rq;
|
|
|
|
|
2009-01-22 22:52:25 +03:00
|
|
|
while (req) {
|
|
|
|
qemu_put_sbyte(f, 1);
|
2016-06-21 15:13:14 +03:00
|
|
|
|
|
|
|
if (s->conf.num_queues > 1) {
|
|
|
|
qemu_put_be32(f, virtio_get_queue_index(req->vq));
|
|
|
|
}
|
|
|
|
|
2019-10-25 11:35:24 +03:00
|
|
|
qemu_put_virtqueue_element(vdev, f, &req->elem);
|
2009-01-22 22:52:25 +03:00
|
|
|
req = req->next;
|
|
|
|
}
|
|
|
|
qemu_put_sbyte(f, 0);
|
2008-12-04 22:52:44 +03:00
|
|
|
}
|
|
|
|
|
2014-06-24 21:19:23 +04:00
|
|
|
static int virtio_blk_load_device(VirtIODevice *vdev, QEMUFile *f,
|
|
|
|
int version_id)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2012-05-16 14:21:35 +04:00
|
|
|
|
2009-01-22 22:52:25 +03:00
|
|
|
while (qemu_get_sbyte(f)) {
|
2016-06-21 15:13:14 +03:00
|
|
|
unsigned nvqs = s->conf.num_queues;
|
|
|
|
unsigned vq_idx = 0;
|
2016-01-31 13:28:59 +03:00
|
|
|
VirtIOBlockReq *req;
|
2016-06-21 15:13:14 +03:00
|
|
|
|
|
|
|
if (nvqs > 1) {
|
|
|
|
vq_idx = qemu_get_be32(f);
|
|
|
|
|
|
|
|
if (vq_idx >= nvqs) {
|
|
|
|
error_report("Invalid virtqueue index in request list: %#x",
|
|
|
|
vq_idx);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-30 13:09:10 +03:00
|
|
|
req = qemu_get_virtqueue_element(vdev, f, sizeof(VirtIOBlockReq));
|
2016-06-21 15:13:14 +03:00
|
|
|
virtio_blk_init_request(s, virtio_get_queue(vdev, vq_idx), req);
|
2009-01-22 22:52:25 +03:00
|
|
|
req->next = s->rq;
|
2010-06-21 12:50:01 +04:00
|
|
|
s->rq = req;
|
2009-01-22 22:52:25 +03:00
|
|
|
}
|
2008-12-04 22:52:44 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-09-16 14:24:12 +03:00
|
|
|
static void virtio_resize_cb(void *opaque)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev = opaque;
|
|
|
|
|
|
|
|
assert(qemu_get_current_aio_context() == qemu_get_aio_context());
|
|
|
|
virtio_notify_config(vdev);
|
|
|
|
}
|
|
|
|
|
2011-08-03 17:07:42 +04:00
|
|
|
static void virtio_blk_resize(void *opaque)
|
2011-01-24 15:32:51 +03:00
|
|
|
{
|
2013-03-18 20:37:27 +04:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(opaque);
|
2011-01-24 15:32:51 +03:00
|
|
|
|
2019-09-16 14:24:12 +03:00
|
|
|
/*
|
|
|
|
* virtio_notify_config() needs to acquire the global mutex,
|
|
|
|
* so it can't be called from an iothread. Instead, schedule
|
|
|
|
* it to be run in the main context BH.
|
|
|
|
*/
|
|
|
|
aio_bh_schedule_oneshot(qemu_get_aio_context(), virtio_resize_cb, vdev);
|
2011-01-24 15:32:51 +03:00
|
|
|
}
|
|
|
|
|
2011-08-03 17:07:41 +04:00
|
|
|
static const BlockDevOps virtio_block_ops = {
|
2011-08-03 17:07:42 +04:00
|
|
|
.resize_cb = virtio_blk_resize,
|
2011-08-03 17:07:41 +04:00
|
|
|
};
|
|
|
|
|
2013-07-30 03:35:08 +04:00
|
|
|
static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
|
2013-03-18 20:37:22 +04:00
|
|
|
{
|
2013-07-30 03:35:08 +04:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
|
2013-07-30 06:48:15 +04:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(dev);
|
2014-10-07 15:59:17 +04:00
|
|
|
VirtIOBlkConf *conf = &s->conf;
|
2013-06-07 18:18:50 +04:00
|
|
|
Error *err = NULL;
|
2016-06-21 15:13:16 +03:00
|
|
|
unsigned i;
|
2009-05-15 01:35:07 +04:00
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
if (!conf->conf.blk) {
|
2013-07-30 03:35:08 +04:00
|
|
|
error_setg(errp, "drive property not set");
|
|
|
|
return;
|
2010-07-06 16:37:43 +04:00
|
|
|
}
|
2014-10-07 15:59:18 +04:00
|
|
|
if (!blk_is_inserted(conf->conf.blk)) {
|
2013-07-30 03:35:08 +04:00
|
|
|
error_setg(errp, "Device needs media, but drive is empty");
|
|
|
|
return;
|
2010-07-06 16:37:44 +04:00
|
|
|
}
|
2020-08-18 17:33:47 +03:00
|
|
|
if (conf->num_queues == VIRTIO_BLK_AUTO_NUM_QUEUES) {
|
|
|
|
conf->num_queues = 1;
|
|
|
|
}
|
2016-06-21 15:13:16 +03:00
|
|
|
if (!conf->num_queues) {
|
|
|
|
error_setg(errp, "num-queues property must be larger than 0");
|
|
|
|
return;
|
|
|
|
}
|
2019-12-20 17:09:04 +03:00
|
|
|
if (conf->queue_size <= 2) {
|
|
|
|
error_setg(errp, "invalid queue-size property (%" PRIu16 "), "
|
|
|
|
"must be > 2", conf->queue_size);
|
|
|
|
return;
|
|
|
|
}
|
2017-12-11 18:16:24 +03:00
|
|
|
if (!is_power_of_2(conf->queue_size) ||
|
|
|
|
conf->queue_size > VIRTQUEUE_MAX_SIZE) {
|
|
|
|
error_setg(errp, "invalid queue-size property (%" PRIu16 "), "
|
|
|
|
"must be a power of 2 (max %d)",
|
|
|
|
conf->queue_size, VIRTQUEUE_MAX_SIZE);
|
|
|
|
return;
|
|
|
|
}
|
2010-07-06 16:37:43 +04:00
|
|
|
|
2017-11-22 06:08:45 +03:00
|
|
|
if (!blkconf_apply_backend_options(&conf->conf,
|
|
|
|
blk_is_read_only(conf->conf.blk), true,
|
|
|
|
errp)) {
|
2017-01-24 15:43:31 +03:00
|
|
|
return;
|
|
|
|
}
|
2014-10-07 15:59:18 +04:00
|
|
|
s->original_wce = blk_enable_write_cache(conf->conf.blk);
|
2017-11-22 06:08:45 +03:00
|
|
|
if (!blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, errp)) {
|
2013-07-30 03:35:08 +04:00
|
|
|
return;
|
2012-07-11 17:08:39 +04:00
|
|
|
}
|
2017-11-22 06:08:45 +03:00
|
|
|
|
2020-05-29 01:55:10 +03:00
|
|
|
if (!blkconf_blocksizes(&conf->conf, errp)) {
|
2017-12-11 18:16:25 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-02-21 13:33:10 +03:00
|
|
|
if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) &&
|
|
|
|
(!conf->max_discard_sectors ||
|
|
|
|
conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) {
|
|
|
|
error_setg(errp, "invalid max-discard-sectors property (%" PRIu32 ")"
|
|
|
|
", must be between 1 and %d",
|
|
|
|
conf->max_discard_sectors, (int)BDRV_REQUEST_MAX_SECTORS);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES) &&
|
|
|
|
(!conf->max_write_zeroes_sectors ||
|
|
|
|
conf->max_write_zeroes_sectors > BDRV_REQUEST_MAX_SECTORS)) {
|
|
|
|
error_setg(errp, "invalid max-write-zeroes-sectors property (%" PRIu32
|
|
|
|
"), must be between 1 and %d",
|
|
|
|
conf->max_write_zeroes_sectors,
|
|
|
|
(int)BDRV_REQUEST_MAX_SECTORS);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-02-21 13:33:09 +03:00
|
|
|
virtio_blk_set_config_size(s, s->host_features);
|
|
|
|
|
|
|
|
virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, s->config_size);
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
s->blk = conf->conf.blk;
|
2009-01-22 22:52:25 +03:00
|
|
|
s->rq = NULL;
|
2014-10-07 15:59:17 +04:00
|
|
|
s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1;
|
2012-07-10 13:12:43 +04:00
|
|
|
|
2016-06-21 15:13:16 +03:00
|
|
|
for (i = 0; i < conf->num_queues; i++) {
|
2017-12-11 18:16:24 +03:00
|
|
|
virtio_add_queue(vdev, conf->queue_size, virtio_blk_handle_output);
|
2016-06-21 15:13:16 +03:00
|
|
|
}
|
2014-10-07 15:59:17 +04:00
|
|
|
virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err);
|
2013-06-07 18:18:50 +04:00
|
|
|
if (err != NULL) {
|
2013-07-30 03:35:08 +04:00
|
|
|
error_propagate(errp, err);
|
2020-03-28 03:57:04 +03:00
|
|
|
for (i = 0; i < conf->num_queues; i++) {
|
|
|
|
virtio_del_queue(vdev, i);
|
|
|
|
}
|
2013-04-24 12:21:22 +04:00
|
|
|
virtio_cleanup(vdev);
|
2013-07-30 03:35:08 +04:00
|
|
|
return;
|
2012-11-14 18:45:38 +04:00
|
|
|
}
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2013-02-22 17:37:10 +04:00
|
|
|
s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
|
2014-10-07 15:59:18 +04:00
|
|
|
blk_set_dev_ops(s->blk, &virtio_block_ops, s);
|
|
|
|
blk_set_guest_block_size(s->blk, s->conf.conf.logical_block_size);
|
2008-12-04 22:52:44 +03:00
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
blk_iostatus_enable(s->blk);
|
2019-10-16 19:41:42 +03:00
|
|
|
|
|
|
|
add_boot_device_lchs(dev, "/disk@0,0",
|
|
|
|
conf->conf.lcyls,
|
|
|
|
conf->conf.lheads,
|
|
|
|
conf->conf.lsecs);
|
2013-03-18 20:37:22 +04:00
|
|
|
}
|
|
|
|
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 18:29:24 +03:00
|
|
|
static void virtio_blk_device_unrealize(DeviceState *dev)
|
2013-03-18 20:37:22 +04:00
|
|
|
{
|
2013-07-30 05:50:44 +04:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
|
|
|
|
VirtIOBlock *s = VIRTIO_BLK(dev);
|
2019-10-25 11:35:22 +03:00
|
|
|
VirtIOBlkConf *conf = &s->conf;
|
|
|
|
unsigned i;
|
2013-07-30 05:50:44 +04:00
|
|
|
|
2019-10-18 17:28:56 +03:00
|
|
|
blk_drain(s->blk);
|
2019-10-16 19:41:42 +03:00
|
|
|
del_boot_device_lchs(dev, "/disk@0,0");
|
2013-03-18 20:37:22 +04:00
|
|
|
virtio_blk_data_plane_destroy(s->dataplane);
|
|
|
|
s->dataplane = NULL;
|
2019-10-25 11:35:22 +03:00
|
|
|
for (i = 0; i < conf->num_queues; i++) {
|
|
|
|
virtio_del_queue(vdev, i);
|
|
|
|
}
|
2013-03-18 20:37:22 +04:00
|
|
|
qemu_del_vm_change_state_handler(s->change);
|
2014-10-07 15:59:18 +04:00
|
|
|
blockdev_mark_auto_del(s->blk);
|
2013-04-24 12:21:22 +04:00
|
|
|
virtio_cleanup(vdev);
|
2013-03-18 20:37:22 +04:00
|
|
|
}
|
|
|
|
|
2014-06-10 11:03:20 +04:00
|
|
|
static void virtio_blk_instance_init(Object *obj)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = VIRTIO_BLK(obj);
|
|
|
|
|
2014-10-07 15:59:17 +04:00
|
|
|
device_add_bootindex_property(obj, &s->conf.conf.bootindex,
|
2014-10-07 12:00:30 +04:00
|
|
|
"bootindex", "/disk@0,0",
|
2020-05-05 18:29:23 +03:00
|
|
|
DEVICE(obj));
|
2014-06-10 11:03:20 +04:00
|
|
|
}
|
|
|
|
|
2016-10-06 15:55:40 +03:00
|
|
|
static const VMStateDescription vmstate_virtio_blk = {
|
|
|
|
.name = "virtio-blk",
|
|
|
|
.minimum_version_id = 2,
|
|
|
|
.version_id = 2,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_VIRTIO_DEVICE,
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
},
|
|
|
|
};
|
2016-07-14 20:22:47 +03:00
|
|
|
|
2013-03-18 20:37:22 +04:00
|
|
|
static Property virtio_blk_properties[] = {
|
2014-10-07 15:59:17 +04:00
|
|
|
DEFINE_BLOCK_PROPERTIES(VirtIOBlock, conf.conf),
|
2016-06-29 18:41:35 +03:00
|
|
|
DEFINE_BLOCK_ERROR_PROPERTIES(VirtIOBlock, conf.conf),
|
2014-10-07 15:59:17 +04:00
|
|
|
DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf),
|
|
|
|
DEFINE_PROP_STRING("serial", VirtIOBlock, conf.serial),
|
2019-02-21 13:33:06 +03:00
|
|
|
DEFINE_PROP_BIT64("config-wce", VirtIOBlock, host_features,
|
|
|
|
VIRTIO_BLK_F_CONFIG_WCE, true),
|
2014-06-18 13:58:36 +04:00
|
|
|
#ifdef __linux__
|
2019-02-21 13:33:06 +03:00
|
|
|
DEFINE_PROP_BIT64("scsi", VirtIOBlock, host_features,
|
|
|
|
VIRTIO_BLK_F_SCSI, false),
|
2014-06-18 13:58:36 +04:00
|
|
|
#endif
|
2015-02-02 16:52:22 +03:00
|
|
|
DEFINE_PROP_BIT("request-merging", VirtIOBlock, conf.request_merging, 0,
|
|
|
|
true),
|
2020-08-18 17:33:47 +03:00
|
|
|
DEFINE_PROP_UINT16("num-queues", VirtIOBlock, conf.num_queues,
|
|
|
|
VIRTIO_BLK_AUTO_NUM_QUEUES),
|
2020-02-14 10:46:48 +03:00
|
|
|
DEFINE_PROP_UINT16("queue-size", VirtIOBlock, conf.queue_size, 256),
|
2019-12-20 17:09:04 +03:00
|
|
|
DEFINE_PROP_BOOL("seg-max-adjust", VirtIOBlock, conf.seg_max_adjust, true),
|
2017-07-14 05:14:55 +03:00
|
|
|
DEFINE_PROP_LINK("iothread", VirtIOBlock, conf.iothread, TYPE_IOTHREAD,
|
|
|
|
IOThread *),
|
2019-02-21 13:33:07 +03:00
|
|
|
DEFINE_PROP_BIT64("discard", VirtIOBlock, host_features,
|
|
|
|
VIRTIO_BLK_F_DISCARD, true),
|
|
|
|
DEFINE_PROP_BIT64("write-zeroes", VirtIOBlock, host_features,
|
|
|
|
VIRTIO_BLK_F_WRITE_ZEROES, true),
|
2019-02-21 13:33:10 +03:00
|
|
|
DEFINE_PROP_UINT32("max-discard-sectors", VirtIOBlock,
|
|
|
|
conf.max_discard_sectors, BDRV_REQUEST_MAX_SECTORS),
|
|
|
|
DEFINE_PROP_UINT32("max-write-zeroes-sectors", VirtIOBlock,
|
|
|
|
conf.max_write_zeroes_sectors, BDRV_REQUEST_MAX_SECTORS),
|
2019-11-05 21:22:17 +03:00
|
|
|
DEFINE_PROP_BOOL("x-enable-wce-if-config-wce", VirtIOBlock,
|
|
|
|
conf.x_enable_wce_if_config_wce, true),
|
2013-03-18 20:37:22 +04:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void virtio_blk_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
|
2013-07-30 03:35:08 +04:00
|
|
|
|
2020-01-10 18:30:32 +03:00
|
|
|
device_class_set_props(dc, virtio_blk_properties);
|
2016-07-14 20:22:47 +03:00
|
|
|
dc->vmsd = &vmstate_virtio_blk;
|
2013-07-29 18:17:45 +04:00
|
|
|
set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
|
2013-07-30 03:35:08 +04:00
|
|
|
vdc->realize = virtio_blk_device_realize;
|
2013-07-30 05:50:44 +04:00
|
|
|
vdc->unrealize = virtio_blk_device_unrealize;
|
2013-03-18 20:37:22 +04:00
|
|
|
vdc->get_config = virtio_blk_update_config;
|
|
|
|
vdc->set_config = virtio_blk_set_config;
|
|
|
|
vdc->get_features = virtio_blk_get_features;
|
|
|
|
vdc->set_status = virtio_blk_set_status;
|
|
|
|
vdc->reset = virtio_blk_reset;
|
2014-06-24 21:19:23 +04:00
|
|
|
vdc->save = virtio_blk_save_device;
|
|
|
|
vdc->load = virtio_blk_load_device;
|
virtio-blk: always use dataplane path if ioeventfd is active
Override start_ioeventfd and stop_ioeventfd to start/stop the
whole dataplane logic. This has some positive side effects:
- no need anymore for virtio_add_queue_aio (i.e. a revert of
commit 0ff841f6d138904d514efa1d885bcaf54583852d)
- no need anymore to switch from generic ioeventfd handlers to
dataplane
It detects some errors better:
$ qemu-system-x86_64 -object iothread,id=io \
-drive id=null,file=null-aio://,if=none,format=raw \
-device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null
qemu-system-x86_64: -device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null:
ioeventfd is required for iothread
while previously it would have started just fine.
Reviewed-by: Cornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2016-10-21 23:48:09 +03:00
|
|
|
vdc->start_ioeventfd = virtio_blk_data_plane_start;
|
|
|
|
vdc->stop_ioeventfd = virtio_blk_data_plane_stop;
|
2013-03-18 20:37:22 +04:00
|
|
|
}
|
|
|
|
|
2016-08-03 11:49:07 +03:00
|
|
|
static const TypeInfo virtio_blk_info = {
|
2013-03-18 20:37:22 +04:00
|
|
|
.name = TYPE_VIRTIO_BLK,
|
|
|
|
.parent = TYPE_VIRTIO_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOBlock),
|
2014-06-10 11:03:20 +04:00
|
|
|
.instance_init = virtio_blk_instance_init,
|
2013-03-18 20:37:22 +04:00
|
|
|
.class_init = virtio_blk_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void virtio_register_types(void)
|
|
|
|
{
|
2016-08-03 11:49:07 +03:00
|
|
|
type_register_static(&virtio_blk_info);
|
2013-03-18 20:37:22 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
type_init(virtio_register_types)
|