2008-12-04 20:52:44 +01: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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-09-08 17:55:32 +02:00
|
|
|
#include "qemu-common.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/error-report.h"
|
2010-05-22 19:15:08 +02:00
|
|
|
#include "trace.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/block/block.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/blockdev.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/virtio/virtio-blk.h"
|
|
|
|
#ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
|
|
|
|
# include "dataplane/virtio-blk.h"
|
|
|
|
#endif
|
|
|
|
#include "block/scsi.h"
|
2009-04-27 10:29:14 +02:00
|
|
|
#ifdef __linux__
|
|
|
|
# include <scsi/sg.h>
|
|
|
|
#endif
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/virtio/virtio-bus.h"
|
2008-12-04 20:52:44 +01:00
|
|
|
|
|
|
|
typedef struct VirtIOBlockReq
|
|
|
|
{
|
|
|
|
VirtIOBlock *dev;
|
|
|
|
VirtQueueElement elem;
|
|
|
|
struct virtio_blk_inhdr *in;
|
|
|
|
struct virtio_blk_outhdr *out;
|
2009-04-27 10:29:14 +02:00
|
|
|
struct virtio_scsi_inhdr *scsi;
|
2009-03-28 18:46:14 +01:00
|
|
|
QEMUIOVector qiov;
|
2009-01-22 20:52:25 +01:00
|
|
|
struct VirtIOBlockReq *next;
|
2011-08-25 08:26:01 +02:00
|
|
|
BlockAcctCookie acct;
|
2008-12-04 20:52:44 +01:00
|
|
|
} VirtIOBlockReq;
|
|
|
|
|
2009-01-22 20:52:25 +01:00
|
|
|
static void virtio_blk_req_complete(VirtIOBlockReq *req, int status)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = req->dev;
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
2009-01-22 20:52:25 +01:00
|
|
|
|
2010-05-22 19:15:08 +02:00
|
|
|
trace_virtio_blk_req_complete(req, status);
|
|
|
|
|
2011-01-25 11:55:14 +01:00
|
|
|
stb_p(&req->in->status, status);
|
2009-03-28 18:46:14 +01:00
|
|
|
virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
|
2013-03-18 17:37:27 +01:00
|
|
|
virtio_notify(vdev, s->vq);
|
2009-01-22 20:52:25 +01:00
|
|
|
}
|
|
|
|
|
2009-11-27 13:25:39 +01:00
|
|
|
static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
|
2012-09-28 17:22:56 +02:00
|
|
|
bool is_read)
|
2009-01-22 20:52:25 +01:00
|
|
|
{
|
2012-09-28 17:22:57 +02:00
|
|
|
BlockErrorAction action = bdrv_get_error_action(req->dev->bs, is_read, error);
|
2009-01-22 20:52:25 +01:00
|
|
|
VirtIOBlock *s = req->dev;
|
|
|
|
|
2012-09-28 17:22:57 +02:00
|
|
|
if (action == BDRV_ACTION_STOP) {
|
2009-01-22 20:52:25 +01:00
|
|
|
req->next = s->rq;
|
|
|
|
s->rq = req;
|
2012-09-28 17:22:57 +02:00
|
|
|
} else if (action == BDRV_ACTION_REPORT) {
|
2009-01-22 20:52:25 +01:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
|
2011-08-25 08:26:01 +02:00
|
|
|
bdrv_acct_done(s->bs, &req->acct);
|
|
|
|
g_free(req);
|
2009-01-22 20:52:25 +01:00
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:57 +02:00
|
|
|
bdrv_error_action(s->bs, action, is_read, error);
|
|
|
|
return action != BDRV_ACTION_IGNORE;
|
2009-01-22 20:52:25 +01:00
|
|
|
}
|
|
|
|
|
2008-12-04 20:52:44 +01:00
|
|
|
static void virtio_blk_rw_complete(void *opaque, int ret)
|
|
|
|
{
|
|
|
|
VirtIOBlockReq *req = opaque;
|
|
|
|
|
2010-05-22 19:15:08 +02:00
|
|
|
trace_virtio_blk_rw_complete(req, ret);
|
|
|
|
|
2009-11-27 13:25:39 +01:00
|
|
|
if (ret) {
|
2012-09-28 17:22:56 +02:00
|
|
|
bool is_read = !(ldl_p(&req->out->type) & VIRTIO_BLK_T_OUT);
|
2009-11-27 13:25:39 +01:00
|
|
|
if (virtio_blk_handle_rw_error(req, -ret, is_read))
|
2009-01-22 20:52:25 +01:00
|
|
|
return;
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
|
|
|
|
2009-11-27 13:25:39 +01:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
|
2011-08-25 08:26:01 +02:00
|
|
|
bdrv_acct_done(req->dev->bs, &req->acct);
|
|
|
|
g_free(req);
|
2009-01-22 20:52:25 +01:00
|
|
|
}
|
2008-12-04 20:52:44 +01:00
|
|
|
|
2009-09-04 19:02:23 +02:00
|
|
|
static void virtio_blk_flush_complete(void *opaque, int ret)
|
|
|
|
{
|
|
|
|
VirtIOBlockReq *req = opaque;
|
|
|
|
|
2010-10-20 13:17:30 +02:00
|
|
|
if (ret) {
|
|
|
|
if (virtio_blk_handle_rw_error(req, -ret, 0)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
|
2011-08-25 08:26:01 +02:00
|
|
|
bdrv_acct_done(req->dev->bs, &req->acct);
|
|
|
|
g_free(req);
|
2009-09-04 19:02:23 +02:00
|
|
|
}
|
|
|
|
|
2009-01-22 20:52:25 +01:00
|
|
|
static VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s)
|
|
|
|
{
|
2011-08-21 05:09:37 +02:00
|
|
|
VirtIOBlockReq *req = g_malloc(sizeof(*req));
|
2009-02-05 23:06:05 +01:00
|
|
|
req->dev = s;
|
2010-05-14 23:52:30 +02:00
|
|
|
req->qiov.size = 0;
|
|
|
|
req->next = NULL;
|
2009-01-22 20:52:25 +01:00
|
|
|
return req;
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s)
|
|
|
|
{
|
2009-01-22 20:52:25 +01:00
|
|
|
VirtIOBlockReq *req = virtio_blk_alloc_request(s);
|
2008-12-04 20:52:44 +01:00
|
|
|
|
2009-01-22 20:52:25 +01:00
|
|
|
if (req != NULL) {
|
|
|
|
if (!virtqueue_pop(s->vq, &req->elem)) {
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(req);
|
2009-01-22 20:52:25 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
2009-04-27 10:29:14 +02:00
|
|
|
static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
|
|
|
|
{
|
2012-05-22 23:23:32 +02:00
|
|
|
#ifdef __linux__
|
2010-01-13 13:30:32 +01:00
|
|
|
int ret;
|
2009-04-27 10:29:14 +02:00
|
|
|
int i;
|
2012-05-22 23:23:32 +02:00
|
|
|
#endif
|
|
|
|
int status = VIRTIO_BLK_S_OK;
|
2009-04-27 10:29:14 +02: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.
|
|
|
|
*/
|
|
|
|
if (req->elem.out_num < 2 || req->elem.in_num < 3) {
|
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
|
2011-08-25 08:26:01 +02:00
|
|
|
g_free(req);
|
2009-04-27 10:29:14 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-05-16 12:54:03 +02:00
|
|
|
* The scsi inhdr is placed in the second-to-last input segment, just
|
|
|
|
* before the regular inhdr.
|
2009-04-27 10:29:14 +02:00
|
|
|
*/
|
2012-05-16 12:54:03 +02:00
|
|
|
req->scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base;
|
|
|
|
|
2013-03-18 17:37:21 +01:00
|
|
|
if (!req->dev->blk.scsi) {
|
2012-05-16 12:54:03 +02:00
|
|
|
status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
goto fail;
|
2009-04-27 10:29:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-05-16 12:54:03 +02:00
|
|
|
* No support for bidirection commands yet.
|
2009-04-27 10:29:14 +02:00
|
|
|
*/
|
2012-05-16 12:54:03 +02:00
|
|
|
if (req->elem.out_num > 2 && req->elem.in_num > 3) {
|
|
|
|
status = VIRTIO_BLK_S_UNSUPP;
|
|
|
|
goto fail;
|
|
|
|
}
|
2009-04-27 10:29:14 +02:00
|
|
|
|
2012-05-16 12:54:03 +02:00
|
|
|
#ifdef __linux__
|
|
|
|
struct sg_io_hdr hdr;
|
2009-04-27 10:29:14 +02:00
|
|
|
memset(&hdr, 0, sizeof(struct sg_io_hdr));
|
|
|
|
hdr.interface_id = 'S';
|
|
|
|
hdr.cmd_len = req->elem.out_sg[1].iov_len;
|
|
|
|
hdr.cmdp = req->elem.out_sg[1].iov_base;
|
|
|
|
hdr.dxfer_len = 0;
|
|
|
|
|
|
|
|
if (req->elem.out_num > 2) {
|
|
|
|
/*
|
|
|
|
* If there are more than the minimally required 2 output segments
|
|
|
|
* there is write payload starting from the third iovec.
|
|
|
|
*/
|
|
|
|
hdr.dxfer_direction = SG_DXFER_TO_DEV;
|
|
|
|
hdr.iovec_count = req->elem.out_num - 2;
|
|
|
|
|
|
|
|
for (i = 0; i < hdr.iovec_count; i++)
|
|
|
|
hdr.dxfer_len += req->elem.out_sg[i + 2].iov_len;
|
|
|
|
|
|
|
|
hdr.dxferp = req->elem.out_sg + 2;
|
|
|
|
|
|
|
|
} else if (req->elem.in_num > 3) {
|
|
|
|
/*
|
|
|
|
* If we have more than 3 input segments the guest wants to actually
|
|
|
|
* read data.
|
|
|
|
*/
|
|
|
|
hdr.dxfer_direction = SG_DXFER_FROM_DEV;
|
|
|
|
hdr.iovec_count = req->elem.in_num - 3;
|
|
|
|
for (i = 0; i < hdr.iovec_count; i++)
|
|
|
|
hdr.dxfer_len += req->elem.in_sg[i].iov_len;
|
|
|
|
|
|
|
|
hdr.dxferp = req->elem.in_sg;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Some SCSI commands don't actually transfer any data.
|
|
|
|
*/
|
|
|
|
hdr.dxfer_direction = SG_DXFER_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
hdr.sbp = req->elem.in_sg[req->elem.in_num - 3].iov_base;
|
|
|
|
hdr.mx_sb_len = req->elem.in_sg[req->elem.in_num - 3].iov_len;
|
|
|
|
|
|
|
|
ret = bdrv_ioctl(req->dev->bs, SG_IO, &hdr);
|
|
|
|
if (ret) {
|
|
|
|
status = VIRTIO_BLK_S_UNSUPP;
|
2012-05-16 12:54:03 +02:00
|
|
|
goto fail;
|
2009-04-27 10:29:14 +02:00
|
|
|
}
|
|
|
|
|
2011-11-02 13:19:40 +01:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
stl_p(&req->scsi->errors,
|
|
|
|
hdr.status | (hdr.msg_status << 8) |
|
|
|
|
(hdr.host_status << 16) | (hdr.driver_status << 24));
|
2011-01-25 11:55:14 +01:00
|
|
|
stl_p(&req->scsi->residual, hdr.resid);
|
|
|
|
stl_p(&req->scsi->sense_len, hdr.sb_len_wr);
|
|
|
|
stl_p(&req->scsi->data_len, hdr.dxfer_len);
|
2009-04-27 10:29:14 +02:00
|
|
|
|
|
|
|
virtio_blk_req_complete(req, status);
|
2011-08-25 08:26:01 +02:00
|
|
|
g_free(req);
|
2012-08-06 14:49:03 +02:00
|
|
|
return;
|
2009-04-27 10:29:14 +02:00
|
|
|
#else
|
2012-05-16 12:54:03 +02:00
|
|
|
abort();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
fail:
|
|
|
|
/* Just put anything nonzero so that the ioctl fails in the guest. */
|
|
|
|
stl_p(&req->scsi->errors, 255);
|
|
|
|
virtio_blk_req_complete(req, status);
|
2011-08-25 08:26:01 +02:00
|
|
|
g_free(req);
|
2009-04-27 10:29:14 +02:00
|
|
|
}
|
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
typedef struct MultiReqBuffer {
|
|
|
|
BlockRequest blkreq[32];
|
|
|
|
unsigned int num_writes;
|
|
|
|
} MultiReqBuffer;
|
|
|
|
|
|
|
|
static void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb)
|
2009-01-22 20:52:25 +01:00
|
|
|
{
|
2009-09-09 17:53:38 +02:00
|
|
|
int i, ret;
|
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
if (!mrb->num_writes) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = bdrv_aio_multiwrite(bs, mrb->blkreq, mrb->num_writes);
|
2009-09-09 17:53:38 +02:00
|
|
|
if (ret != 0) {
|
2010-06-08 18:26:07 +02:00
|
|
|
for (i = 0; i < mrb->num_writes; i++) {
|
|
|
|
if (mrb->blkreq[i].error) {
|
|
|
|
virtio_blk_rw_complete(mrb->blkreq[i].opaque, -EIO);
|
2009-09-09 17:53:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-06-08 18:26:07 +02:00
|
|
|
|
|
|
|
mrb->num_writes = 0;
|
2009-09-09 17:53:38 +02:00
|
|
|
}
|
2009-08-13 16:49:56 +02:00
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb)
|
2009-09-04 19:02:23 +02:00
|
|
|
{
|
2011-08-25 08:26:01 +02:00
|
|
|
bdrv_acct_start(req->dev->bs, &req->acct, 0, BDRV_ACCT_FLUSH);
|
|
|
|
|
2010-05-19 12:40:09 +02:00
|
|
|
/*
|
|
|
|
* Make sure all outstanding writes are posted to the backing device.
|
|
|
|
*/
|
2010-06-08 18:26:07 +02:00
|
|
|
virtio_submit_multiwrite(req->dev->bs, mrb);
|
2011-11-30 09:12:30 +01:00
|
|
|
bdrv_aio_flush(req->dev->bs, virtio_blk_flush_complete, req);
|
2009-09-04 19:02:23 +02:00
|
|
|
}
|
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
static void virtio_blk_handle_write(VirtIOBlockReq *req, MultiReqBuffer *mrb)
|
2009-09-09 17:53:38 +02:00
|
|
|
{
|
2010-06-08 18:26:07 +02:00
|
|
|
BlockRequest *blkreq;
|
2011-01-25 11:55:14 +01:00
|
|
|
uint64_t sector;
|
2010-06-08 18:26:07 +02:00
|
|
|
|
2011-01-25 11:55:14 +01:00
|
|
|
sector = ldq_p(&req->out->sector);
|
2010-05-22 19:15:08 +02:00
|
|
|
|
2011-08-25 08:26:01 +02:00
|
|
|
bdrv_acct_start(req->dev->bs, &req->acct, req->qiov.size, BDRV_ACCT_WRITE);
|
|
|
|
|
2011-01-25 11:55:14 +01:00
|
|
|
trace_virtio_blk_handle_write(req, sector, req->qiov.size / 512);
|
|
|
|
|
|
|
|
if (sector & req->dev->sector_mask) {
|
2010-03-04 14:20:17 +01:00
|
|
|
virtio_blk_rw_complete(req, -EIO);
|
|
|
|
return;
|
|
|
|
}
|
2011-04-06 20:28:34 +02:00
|
|
|
if (req->qiov.size % req->dev->conf->logical_block_size) {
|
|
|
|
virtio_blk_rw_complete(req, -EIO);
|
|
|
|
return;
|
|
|
|
}
|
2010-03-04 14:20:17 +01:00
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
if (mrb->num_writes == 32) {
|
|
|
|
virtio_submit_multiwrite(req->dev->bs, mrb);
|
2009-08-13 16:49:56 +02:00
|
|
|
}
|
2009-09-09 17:53:38 +02:00
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
blkreq = &mrb->blkreq[mrb->num_writes];
|
2011-01-25 11:55:14 +01:00
|
|
|
blkreq->sector = sector;
|
2010-06-08 18:26:07 +02:00
|
|
|
blkreq->nb_sectors = req->qiov.size / BDRV_SECTOR_SIZE;
|
|
|
|
blkreq->qiov = &req->qiov;
|
|
|
|
blkreq->cb = virtio_blk_rw_complete;
|
|
|
|
blkreq->opaque = req;
|
|
|
|
blkreq->error = 0;
|
2009-09-09 17:53:38 +02:00
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
mrb->num_writes++;
|
2009-03-28 18:46:14 +01:00
|
|
|
}
|
2009-01-22 20:52:25 +01:00
|
|
|
|
2009-03-28 18:46:14 +01:00
|
|
|
static void virtio_blk_handle_read(VirtIOBlockReq *req)
|
|
|
|
{
|
2011-01-25 11:55:14 +01:00
|
|
|
uint64_t sector;
|
|
|
|
|
|
|
|
sector = ldq_p(&req->out->sector);
|
2009-08-13 16:49:56 +02:00
|
|
|
|
2011-08-25 08:26:01 +02:00
|
|
|
bdrv_acct_start(req->dev->bs, &req->acct, req->qiov.size, BDRV_ACCT_READ);
|
|
|
|
|
2011-12-22 14:17:02 +01:00
|
|
|
trace_virtio_blk_handle_read(req, sector, req->qiov.size / 512);
|
|
|
|
|
2011-01-25 11:55:14 +01:00
|
|
|
if (sector & req->dev->sector_mask) {
|
2010-03-04 14:20:17 +01:00
|
|
|
virtio_blk_rw_complete(req, -EIO);
|
|
|
|
return;
|
|
|
|
}
|
2011-04-06 20:28:34 +02:00
|
|
|
if (req->qiov.size % req->dev->conf->logical_block_size) {
|
|
|
|
virtio_blk_rw_complete(req, -EIO);
|
|
|
|
return;
|
|
|
|
}
|
2011-11-30 09:12:30 +01:00
|
|
|
bdrv_aio_readv(req->dev->bs, sector, &req->qiov,
|
|
|
|
req->qiov.size / BDRV_SECTOR_SIZE,
|
|
|
|
virtio_blk_rw_complete, req);
|
2009-01-22 20:52:25 +01:00
|
|
|
}
|
|
|
|
|
2010-01-27 13:12:34 +01:00
|
|
|
static void virtio_blk_handle_request(VirtIOBlockReq *req,
|
|
|
|
MultiReqBuffer *mrb)
|
|
|
|
{
|
2011-01-25 11:55:14 +01:00
|
|
|
uint32_t type;
|
|
|
|
|
2010-01-27 13:12:34 +01:00
|
|
|
if (req->elem.out_num < 1 || req->elem.in_num < 1) {
|
2010-11-15 21:44:35 +01:00
|
|
|
error_report("virtio-blk missing headers");
|
2010-01-27 13:12:34 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req->elem.out_sg[0].iov_len < sizeof(*req->out) ||
|
|
|
|
req->elem.in_sg[req->elem.in_num - 1].iov_len < sizeof(*req->in)) {
|
2010-11-15 21:44:35 +01:00
|
|
|
error_report("virtio-blk header not in correct element");
|
2010-01-27 13:12:34 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
req->out = (void *)req->elem.out_sg[0].iov_base;
|
|
|
|
req->in = (void *)req->elem.in_sg[req->elem.in_num - 1].iov_base;
|
|
|
|
|
2011-01-25 11:55:14 +01:00
|
|
|
type = ldl_p(&req->out->type);
|
|
|
|
|
|
|
|
if (type & VIRTIO_BLK_T_FLUSH) {
|
2010-06-08 18:26:07 +02:00
|
|
|
virtio_blk_handle_flush(req, mrb);
|
2011-01-25 11:55:14 +01:00
|
|
|
} else if (type & VIRTIO_BLK_T_SCSI_CMD) {
|
2010-01-27 13:12:34 +01:00
|
|
|
virtio_blk_handle_scsi(req);
|
2011-01-25 11:55:14 +01:00
|
|
|
} else if (type & VIRTIO_BLK_T_GET_ID) {
|
2010-07-02 19:44:25 +02:00
|
|
|
VirtIOBlock *s = req->dev;
|
|
|
|
|
2011-06-20 11:35:18 +02:00
|
|
|
/*
|
|
|
|
* NB: per existing s/n string convention the string is
|
|
|
|
* terminated by '\0' only when shorter than buffer.
|
|
|
|
*/
|
|
|
|
strncpy(req->elem.in_sg[0].iov_base,
|
2013-03-18 17:37:21 +01:00
|
|
|
s->blk.serial ? s->blk.serial : "",
|
2011-06-20 11:35:18 +02:00
|
|
|
MIN(req->elem.in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES));
|
2010-07-02 19:44:25 +02:00
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
|
2011-08-25 08:26:01 +02:00
|
|
|
g_free(req);
|
2011-01-25 11:55:14 +01:00
|
|
|
} else if (type & VIRTIO_BLK_T_OUT) {
|
2010-01-27 13:12:34 +01:00
|
|
|
qemu_iovec_init_external(&req->qiov, &req->elem.out_sg[1],
|
|
|
|
req->elem.out_num - 1);
|
2010-06-08 18:26:07 +02:00
|
|
|
virtio_blk_handle_write(req, mrb);
|
2012-12-13 08:03:43 +01:00
|
|
|
} else if (type == VIRTIO_BLK_T_IN || type == VIRTIO_BLK_T_BARRIER) {
|
|
|
|
/* VIRTIO_BLK_T_IN is 0, so we can't just & it. */
|
2010-01-27 13:12:34 +01:00
|
|
|
qemu_iovec_init_external(&req->qiov, &req->elem.in_sg[0],
|
|
|
|
req->elem.in_num - 1);
|
|
|
|
virtio_blk_handle_read(req);
|
2012-12-13 08:03:43 +01:00
|
|
|
} else {
|
|
|
|
virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
|
|
|
|
g_free(req);
|
2010-01-27 13:12:34 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-04 20:52:44 +01:00
|
|
|
static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
|
|
|
|
{
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2008-12-04 20:52:44 +01:00
|
|
|
VirtIOBlockReq *req;
|
2010-01-27 13:12:34 +01:00
|
|
|
MultiReqBuffer mrb = {
|
|
|
|
.num_writes = 0,
|
|
|
|
};
|
2008-12-04 20:52:44 +01:00
|
|
|
|
2012-11-14 15:45:38 +01:00
|
|
|
#ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
|
|
|
|
/* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
|
|
|
|
* dataplane here instead of waiting for .set_status().
|
|
|
|
*/
|
|
|
|
if (s->dataplane) {
|
|
|
|
virtio_blk_data_plane_start(s->dataplane);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-12-04 20:52:44 +01:00
|
|
|
while ((req = virtio_blk_get_request(s))) {
|
2010-01-27 13:12:34 +01:00
|
|
|
virtio_blk_handle_request(req, &mrb);
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
2009-09-09 17:53:38 +02:00
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
virtio_submit_multiwrite(s->bs, &mrb);
|
2009-09-09 17:53:38 +02:00
|
|
|
|
2008-12-04 20:52:44 +01:00
|
|
|
/*
|
|
|
|
* FIXME: Want to check for completions before returning to guest mode,
|
|
|
|
* so cached reads and writes are reported as quickly as possible. But
|
|
|
|
* that should be done in the generic block layer.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2009-07-28 20:33:41 +02:00
|
|
|
static void virtio_blk_dma_restart_bh(void *opaque)
|
2009-01-22 20:52:25 +01:00
|
|
|
{
|
|
|
|
VirtIOBlock *s = opaque;
|
|
|
|
VirtIOBlockReq *req = s->rq;
|
2010-01-27 13:12:35 +01:00
|
|
|
MultiReqBuffer mrb = {
|
|
|
|
.num_writes = 0,
|
|
|
|
};
|
2009-01-22 20:52:25 +01:00
|
|
|
|
2009-07-28 20:33:41 +02:00
|
|
|
qemu_bh_delete(s->bh);
|
|
|
|
s->bh = NULL;
|
2009-01-22 20:52:25 +01:00
|
|
|
|
|
|
|
s->rq = NULL;
|
|
|
|
|
|
|
|
while (req) {
|
2010-01-27 13:12:35 +01:00
|
|
|
virtio_blk_handle_request(req, &mrb);
|
2009-01-22 20:52:25 +01:00
|
|
|
req = req->next;
|
|
|
|
}
|
2010-01-27 13:12:35 +01:00
|
|
|
|
2010-06-08 18:26:07 +02:00
|
|
|
virtio_submit_multiwrite(s->bs, &mrb);
|
2009-01-22 20:52:25 +01:00
|
|
|
}
|
|
|
|
|
2011-07-29 19:26:33 +02:00
|
|
|
static void virtio_blk_dma_restart_cb(void *opaque, int running,
|
|
|
|
RunState state)
|
2009-07-28 20:33:41 +02:00
|
|
|
{
|
|
|
|
VirtIOBlock *s = opaque;
|
|
|
|
|
2012-11-14 15:45:38 +01:00
|
|
|
if (!running) {
|
2009-07-28 20:33:41 +02:00
|
|
|
return;
|
2012-11-14 15:45:38 +01:00
|
|
|
}
|
2009-07-28 20:33:41 +02:00
|
|
|
|
|
|
|
if (!s->bh) {
|
|
|
|
s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s);
|
|
|
|
qemu_bh_schedule(s->bh);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-04 20:52:44 +01:00
|
|
|
static void virtio_blk_reset(VirtIODevice *vdev)
|
|
|
|
{
|
2012-11-14 15:45:38 +01:00
|
|
|
#ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2012-11-14 15:45:38 +01:00
|
|
|
|
|
|
|
if (s->dataplane) {
|
|
|
|
virtio_blk_data_plane_stop(s->dataplane);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-12-04 20:52:44 +01:00
|
|
|
/*
|
|
|
|
* This should cancel pending requests, but can't do nicely until there
|
|
|
|
* are per-device request lists.
|
|
|
|
*/
|
2011-11-30 13:23:43 +01:00
|
|
|
bdrv_drain_all();
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
|
|
|
|
2009-06-22 20:26:51 +02:00
|
|
|
/* coalesce internal state, copy to pci i/o region 0
|
|
|
|
*/
|
2008-12-04 20:52:44 +01:00
|
|
|
static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
|
|
|
|
{
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2008-12-04 20:52:44 +01:00
|
|
|
struct virtio_blk_config blkcfg;
|
|
|
|
uint64_t capacity;
|
2011-11-18 16:31:59 +01:00
|
|
|
int blk_size = s->conf->logical_block_size;
|
2008-12-04 20:52:44 +01:00
|
|
|
|
|
|
|
bdrv_get_geometry(s->bs, &capacity);
|
2009-06-12 09:50:18 +02:00
|
|
|
memset(&blkcfg, 0, sizeof(blkcfg));
|
2008-12-04 20:52:44 +01:00
|
|
|
stq_raw(&blkcfg.capacity, capacity);
|
|
|
|
stl_raw(&blkcfg.seg_max, 128 - 2);
|
2012-07-10 11:12:43 +02:00
|
|
|
stw_raw(&blkcfg.cylinders, s->conf->cyls);
|
2011-11-18 16:31:59 +01:00
|
|
|
stl_raw(&blkcfg.blk_size, blk_size);
|
|
|
|
stw_raw(&blkcfg.min_io_size, s->conf->min_io_size / blk_size);
|
|
|
|
stw_raw(&blkcfg.opt_io_size, s->conf->opt_io_size / blk_size);
|
2012-07-10 11:12:43 +02:00
|
|
|
blkcfg.heads = s->conf->heads;
|
2012-05-24 13:22:55 +02:00
|
|
|
/*
|
|
|
|
* We must ensure that the block device capacity is a multiple of
|
2013-04-09 13:48:19 +02:00
|
|
|
* the logical block size. If that is not the case, let's use
|
2012-05-24 13:22:55 +02: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 13:48:19 +02:00
|
|
|
* we don't touch the sector value of the geometry, since some devices
|
2012-05-24 13:22:55 +02: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).
|
|
|
|
*/
|
2012-07-10 11:12:43 +02:00
|
|
|
if (bdrv_getlength(s->bs) / s->conf->heads / s->conf->secs % blk_size) {
|
|
|
|
blkcfg.sectors = s->conf->secs & ~s->sector_mask;
|
2012-05-24 13:22:55 +02:00
|
|
|
} else {
|
2012-07-10 11:12:43 +02:00
|
|
|
blkcfg.sectors = s->conf->secs;
|
2012-05-24 13:22:55 +02:00
|
|
|
}
|
2009-06-13 15:20:25 +02:00
|
|
|
blkcfg.size_max = 0;
|
2010-02-10 23:37:25 +01:00
|
|
|
blkcfg.physical_block_exp = get_physical_block_exp(s->conf);
|
|
|
|
blkcfg.alignment_offset = 0;
|
2012-08-09 16:07:19 +02:00
|
|
|
blkcfg.wce = bdrv_enable_write_cache(s->bs);
|
2010-02-10 23:36:49 +01:00
|
|
|
memcpy(config, &blkcfg, sizeof(struct virtio_blk_config));
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
|
|
|
|
2012-08-09 16:07:19 +02:00
|
|
|
static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
|
|
|
|
{
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2012-08-09 16:07:19 +02:00
|
|
|
struct virtio_blk_config blkcfg;
|
|
|
|
|
|
|
|
memcpy(&blkcfg, config, sizeof(blkcfg));
|
|
|
|
bdrv_set_enable_write_cache(s->bs, blkcfg.wce != 0);
|
|
|
|
}
|
|
|
|
|
2010-01-10 12:52:53 +01:00
|
|
|
static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features)
|
2008-12-04 20:52:44 +01:00
|
|
|
{
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2009-04-27 10:29:14 +02:00
|
|
|
|
|
|
|
features |= (1 << VIRTIO_BLK_F_SEG_MAX);
|
|
|
|
features |= (1 << VIRTIO_BLK_F_GEOMETRY);
|
2010-02-10 23:37:25 +01:00
|
|
|
features |= (1 << VIRTIO_BLK_F_TOPOLOGY);
|
2010-03-04 14:20:17 +01:00
|
|
|
features |= (1 << VIRTIO_BLK_F_BLK_SIZE);
|
virtio-blk: always enable VIRTIO_BLK_F_SCSI
VIRTIO_BLK_F_SCSI is supposed to mean whether the host can *parse*
SCSI requests, not *execute* them. You could run QEMU with scsi=on
and a file-backed disk, and QEMU would fail all SCSI requests even
though it advertises VIRTIO_BLK_F_SCSI.
Because we need to do this to fix a migration compatibility problem
related to how QEMU is invoked by management, we must do this
unconditionally even on older machine types. This more or less assumes
that no one ever invoked QEMU with scsi=off.
Here is how testing goes:
- old QEMU, scsi=on -> new QEMU, scsi=on
- new QEMU, scsi=on -> old QEMU, scsi=on
- old QEMU, scsi=off -> new QEMU, scsi=on
- new QEMU, scsi=off -> old QEMU, scsi=on
ok (new QEMU has VIRTIO_BLK_F_SCSI, adding host features is fine)
- old QEMU, scsi=off -> new QEMU, scsi=off
ok (new QEMU has VIRTIO_BLK_F_SCSI, adding host features is fine)
- old QEMU, scsi=on -> new QEMU, scsi=off
ok, bug fixed
- new QEMU, scsi=on -> old QEMU, scsi=off
doesn't work (same as: old QEMU, scsi=on -> old QEMU, scsi=off)
- new QEMU, scsi=off -> old QEMU, scsi=off
broken by the patch
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2012-05-16 12:54:06 +02:00
|
|
|
features |= (1 << VIRTIO_BLK_F_SCSI);
|
2009-09-04 19:02:23 +02:00
|
|
|
|
2013-03-18 17:37:21 +01:00
|
|
|
if (s->blk.config_wce) {
|
2012-12-10 13:14:39 +01:00
|
|
|
features |= (1 << VIRTIO_BLK_F_CONFIG_WCE);
|
|
|
|
}
|
2009-09-04 19:02:23 +02:00
|
|
|
if (bdrv_enable_write_cache(s->bs))
|
2012-08-09 16:07:19 +02:00
|
|
|
features |= (1 << VIRTIO_BLK_F_WCE);
|
|
|
|
|
2009-10-29 10:42:11 +01:00
|
|
|
if (bdrv_is_read_only(s->bs))
|
|
|
|
features |= 1 << VIRTIO_BLK_F_RO;
|
2009-04-27 10:29:14 +02:00
|
|
|
|
|
|
|
return features;
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
|
|
|
|
2012-08-09 16:07:20 +02:00
|
|
|
static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status)
|
|
|
|
{
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
2012-08-09 16:07:20 +02:00
|
|
|
uint32_t features;
|
|
|
|
|
2012-11-14 15:45:38 +01:00
|
|
|
#ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
|
2013-01-17 16:46:54 +01:00
|
|
|
if (s->dataplane && !(status & (VIRTIO_CONFIG_S_DRIVER |
|
|
|
|
VIRTIO_CONFIG_S_DRIVER_OK))) {
|
2012-11-14 15:45:38 +01:00
|
|
|
virtio_blk_data_plane_stop(s->dataplane);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-08-09 16:07:20 +02:00
|
|
|
if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
features = vdev->guest_features;
|
|
|
|
bdrv_set_enable_write_cache(s->bs, !!(features & (1 << VIRTIO_BLK_F_WCE)));
|
|
|
|
}
|
|
|
|
|
2008-12-04 20:52:44 +01:00
|
|
|
static void virtio_blk_save(QEMUFile *f, void *opaque)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = opaque;
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
2009-01-22 20:52:25 +01:00
|
|
|
VirtIOBlockReq *req = s->rq;
|
|
|
|
|
2013-03-18 17:37:27 +01:00
|
|
|
virtio_save(vdev, f);
|
2009-01-22 20:52:25 +01:00
|
|
|
|
|
|
|
while (req) {
|
|
|
|
qemu_put_sbyte(f, 1);
|
|
|
|
qemu_put_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem));
|
|
|
|
req = req->next;
|
|
|
|
}
|
|
|
|
qemu_put_sbyte(f, 0);
|
2008-12-04 20:52:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int virtio_blk_load(QEMUFile *f, void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
VirtIOBlock *s = opaque;
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(s);
|
2012-05-16 12:21:35 +02:00
|
|
|
int ret;
|
2008-12-04 20:52:44 +01:00
|
|
|
|
2009-01-22 20:52:25 +01:00
|
|
|
if (version_id != 2)
|
2008-12-04 20:52:44 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-03-18 17:37:27 +01:00
|
|
|
ret = virtio_load(vdev, f);
|
2012-05-16 12:21:35 +02:00
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-22 20:52:25 +01:00
|
|
|
while (qemu_get_sbyte(f)) {
|
|
|
|
VirtIOBlockReq *req = virtio_blk_alloc_request(s);
|
|
|
|
qemu_get_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem));
|
|
|
|
req->next = s->rq;
|
2010-06-21 10:50:01 +02:00
|
|
|
s->rq = req;
|
2010-08-03 16:57:02 +02:00
|
|
|
|
|
|
|
virtqueue_map_sg(req->elem.in_sg, req->elem.in_addr,
|
|
|
|
req->elem.in_num, 1);
|
|
|
|
virtqueue_map_sg(req->elem.out_sg, req->elem.out_addr,
|
|
|
|
req->elem.out_num, 0);
|
2009-01-22 20:52:25 +01:00
|
|
|
}
|
2008-12-04 20:52:44 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-03 15:07:42 +02:00
|
|
|
static void virtio_blk_resize(void *opaque)
|
2011-01-24 13:32:51 +01:00
|
|
|
{
|
2013-03-18 17:37:27 +01:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(opaque);
|
2011-01-24 13:32:51 +01:00
|
|
|
|
2013-03-18 17:37:27 +01:00
|
|
|
virtio_notify_config(vdev);
|
2011-01-24 13:32:51 +01:00
|
|
|
}
|
|
|
|
|
2011-08-03 15:07:41 +02:00
|
|
|
static const BlockDevOps virtio_block_ops = {
|
2011-08-03 15:07:42 +02:00
|
|
|
.resize_cb = virtio_blk_resize,
|
2011-08-03 15:07:41 +02:00
|
|
|
};
|
|
|
|
|
2013-03-18 17:37:22 +01:00
|
|
|
void virtio_blk_set_conf(DeviceState *dev, VirtIOBlkConf *blk)
|
2008-12-04 20:52:44 +01:00
|
|
|
{
|
2013-03-18 17:37:22 +01:00
|
|
|
VirtIOBlock *s = VIRTIO_BLK(dev);
|
|
|
|
memcpy(&(s->blk), blk, sizeof(struct VirtIOBlkConf));
|
|
|
|
}
|
|
|
|
|
2013-03-18 17:37:26 +01:00
|
|
|
static int virtio_blk_device_init(VirtIODevice *vdev)
|
2013-03-18 17:37:22 +01:00
|
|
|
{
|
2013-03-18 17:37:26 +01:00
|
|
|
DeviceState *qdev = DEVICE(vdev);
|
|
|
|
VirtIOBlock *s = VIRTIO_BLK(vdev);
|
|
|
|
VirtIOBlkConf *blk = &(s->blk);
|
2008-12-04 20:52:44 +01:00
|
|
|
static int virtio_blk_id;
|
2009-05-14 23:35:07 +02:00
|
|
|
|
2012-05-16 12:54:05 +02:00
|
|
|
if (!blk->conf.bs) {
|
2011-12-21 11:37:57 +01:00
|
|
|
error_report("drive property not set");
|
2013-03-18 17:37:26 +01:00
|
|
|
return -1;
|
2010-07-06 14:37:43 +02:00
|
|
|
}
|
2012-05-16 12:54:05 +02:00
|
|
|
if (!bdrv_is_inserted(blk->conf.bs)) {
|
2010-07-06 14:37:44 +02:00
|
|
|
error_report("Device needs media, but drive is empty");
|
2013-03-18 17:37:26 +01:00
|
|
|
return -1;
|
2010-07-06 14:37:44 +02:00
|
|
|
}
|
2010-07-06 14:37:43 +02:00
|
|
|
|
2012-07-11 15:08:37 +02:00
|
|
|
blkconf_serial(&blk->conf, &blk->serial);
|
2012-07-11 15:08:39 +02:00
|
|
|
if (blkconf_geometry(&blk->conf, NULL, 65535, 255, 255) < 0) {
|
2013-03-18 17:37:26 +01:00
|
|
|
return -1;
|
2012-07-11 15:08:39 +02:00
|
|
|
}
|
2011-06-20 11:35:18 +02:00
|
|
|
|
2013-03-18 17:37:26 +01:00
|
|
|
virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,
|
|
|
|
sizeof(struct virtio_blk_config));
|
2008-12-04 20:52:44 +01:00
|
|
|
|
2013-03-18 17:37:26 +01:00
|
|
|
vdev->get_config = virtio_blk_update_config;
|
|
|
|
vdev->set_config = virtio_blk_set_config;
|
|
|
|
vdev->get_features = virtio_blk_get_features;
|
|
|
|
vdev->set_status = virtio_blk_set_status;
|
|
|
|
vdev->reset = virtio_blk_reset;
|
2012-05-16 12:54:05 +02:00
|
|
|
s->bs = blk->conf.bs;
|
|
|
|
s->conf = &blk->conf;
|
2013-03-18 17:37:21 +01:00
|
|
|
memcpy(&(s->blk), blk, sizeof(struct VirtIOBlkConf));
|
2009-01-22 20:52:25 +01:00
|
|
|
s->rq = NULL;
|
2010-05-27 16:20:33 +02:00
|
|
|
s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1;
|
2012-07-10 11:12:43 +02:00
|
|
|
|
2013-03-18 17:37:26 +01:00
|
|
|
s->vq = virtio_add_queue(vdev, 128, virtio_blk_handle_output);
|
2012-11-14 15:45:38 +01:00
|
|
|
#ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
|
2013-03-18 17:37:26 +01:00
|
|
|
if (!virtio_blk_data_plane_create(vdev, blk, &s->dataplane)) {
|
virtio-blk: Do not segfault fault if failed to initialize dataplane
$ ~/usr/bin/qemu-system-x86_64 -enable-kvm -m 1024 -drive if=none,id=drive0,cache=none,aio=native,format=raw,file=/root/Image/centos-6.4.raw -device virtio-blk-pci,drive=drive0,scsi=off,x-data-plane=on,config-wce=on # make dataplane fail to initialize
qemu-system-x86_64: -device virtio-blk-pci,drive=drive0,scsi=off,x-data-plane=on,config-wce=on: device is incompatible with x-data-plane, use config-wce=off
*** glibc detected *** /root/usr/bin/qemu-system-x86_64: free(): invalid pointer: 0x00007f001fef12f8 ***
======= Backtrace: =========
/lib64/libc.so.6(+0x7d776)[0x7f00153a5776]
/root/usr/bin/qemu-system-x86_64(+0x2c34ec)[0x7f001cf5b4ec]
/root/usr/bin/qemu-system-x86_64(+0x342f9a)[0x7f001cfdaf9a]
/root/usr/bin/qemu-system-x86_64(+0x33694e)[0x7f001cfce94e]
....................
(gdb) bt
#0 0x00007f3bf3a12015 in raise () from /lib64/libc.so.6
#1 0x00007f3bf3a1348b in abort () from /lib64/libc.so.6
#2 0x00007f3bf3a51a4e in __libc_message () from /lib64/libc.so.6
#3 0x00007f3bf3a57776 in malloc_printerr () from /lib64/libc.so.6
#4 0x00007f3bfb60d4ec in free_and_trace (mem=0x7f3bfe0129f8) at vl.c:2786
#5 0x00007f3bfb68cf9a in virtio_cleanup (vdev=0x7f3bfe0129f8) at /root/Develop/QEMU/qemu/hw/virtio.c:900
#6 0x00007f3bfb68094e in virtio_blk_device_init (vdev=0x7f3bfe0129f8) at /root/Develop/QEMU/qemu/hw/virtio-blk.c:666
#7 0x00007f3bfb68dadf in virtio_device_init (qdev=0x7f3bfe0129f8) at /root/Develop/QEMU/qemu/hw/virtio.c:1092
#8 0x00007f3bfb50da46 in device_realize (dev=0x7f3bfe0129f8, err=0x7fff479c9258) at hw/qdev.c:176
.............................
In virtio_blk_device_init(), the memory which vdev point to is a static
member of "struct VirtIOBlkPCI", not heap memory, and it does not
get freed. So we shoule use virtio_common_cleanup() to clean this VirtIODevice
rather than virtio_cleanup(), which attempts to free the vdev.
This error was introduced by commit 05ff686536f408ba6e8426b1b54d25bd3379fda2
recently.
Signed-off-by: Dunrong Huang <huangdr@cloud-times.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-03-19 09:27:29 +01:00
|
|
|
virtio_common_cleanup(vdev);
|
2013-03-18 17:37:26 +01:00
|
|
|
return -1;
|
2012-11-14 15:45:38 +01:00
|
|
|
}
|
|
|
|
#endif
|
2008-12-04 20:52:44 +01:00
|
|
|
|
2013-02-22 14:37:10 +01:00
|
|
|
s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
|
2013-03-18 17:37:26 +01:00
|
|
|
register_savevm(qdev, "virtio-blk", virtio_blk_id++, 2,
|
2008-12-04 20:52:44 +01:00
|
|
|
virtio_blk_save, virtio_blk_load, s);
|
2011-08-03 15:07:41 +02:00
|
|
|
bdrv_set_dev_ops(s->bs, &virtio_block_ops, s);
|
2012-05-16 12:54:05 +02:00
|
|
|
bdrv_set_buffer_alignment(s->bs, s->conf->logical_block_size);
|
2008-12-04 20:52:44 +01:00
|
|
|
|
2011-09-26 22:43:51 +02:00
|
|
|
bdrv_iostatus_enable(s->bs);
|
2010-12-08 12:35:05 +01:00
|
|
|
|
2013-03-18 17:37:26 +01:00
|
|
|
add_boot_device_path(s->conf->bootindex, qdev, "/disk@0,0");
|
2013-03-18 17:37:22 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int virtio_blk_device_exit(DeviceState *dev)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
|
|
|
|
VirtIOBlock *s = VIRTIO_BLK(dev);
|
|
|
|
#ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
|
|
|
|
virtio_blk_data_plane_destroy(s->dataplane);
|
|
|
|
s->dataplane = NULL;
|
|
|
|
#endif
|
|
|
|
qemu_del_vm_change_state_handler(s->change);
|
2013-03-18 17:37:28 +01:00
|
|
|
unregister_savevm(dev, "virtio-blk", s);
|
2013-03-18 17:37:22 +01:00
|
|
|
blockdev_mark_auto_del(s->bs);
|
|
|
|
virtio_common_cleanup(vdev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Property virtio_blk_properties[] = {
|
|
|
|
DEFINE_VIRTIO_BLK_PROPERTIES(VirtIOBlock, blk),
|
|
|
|
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);
|
|
|
|
dc->exit = virtio_blk_device_exit;
|
|
|
|
dc->props = virtio_blk_properties;
|
|
|
|
vdc->init = virtio_blk_device_init;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo virtio_device_info = {
|
|
|
|
.name = TYPE_VIRTIO_BLK,
|
|
|
|
.parent = TYPE_VIRTIO_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOBlock),
|
|
|
|
.class_init = virtio_blk_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void virtio_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(&virtio_device_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
type_init(virtio_register_types)
|