david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

virtio-blk: use virtio wrappers to access headers

Browse Source 
Note that st*_raw and ld*_raw are effectively replaced by st*_p and ld*_p.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
Reviewed-by: Anthony Liguori <aliguori@us.ibm.com>
[ pass VirtIODevice * to memory accessors,
  Greg Kurz <gkurz@linux.vnet.ibm.com> ]
Signed-off-by: Greg Kurz <gkurz@linux.vnet.ibm.com>
Reviewed-by: Alexander Graf <agraf@suse.de>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Rusty Russell 2014-06-24 19:43:44 +02:00 committed by Michael S. Tsirkin
parent 8609d2a87a
commit 783d189725
1 changed files with 21 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
hw/block/virtio-blk.c
View File

@ -27,6 +27,7 @@
# include <scsi/sg.h> # include <scsi/sg.h>
#endif #endif
#include "hw/virtio/virtio-bus.h" #include "hw/virtio/virtio-bus.h"
#include "hw/virtio/virtio-access.h"
static VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s) static VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s)
{ {
@ -88,7 +89,8 @@ static void virtio_blk_rw_complete(void *opaque, int ret)
trace_virtio_blk_rw_complete(req, ret); trace_virtio_blk_rw_complete(req, ret);
if (ret) { if (ret) {
bool is_read = !(ldl_p(&req->out.type) & VIRTIO_BLK_T_OUT); int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
bool is_read = !(p & VIRTIO_BLK_T_OUT);
if (virtio_blk_handle_rw_error(req, -ret, is_read)) if (virtio_blk_handle_rw_error(req, -ret, is_read))
return; return;
} }
@ -130,6 +132,8 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk,
{ {
int status = VIRTIO_BLK_S_OK; int status = VIRTIO_BLK_S_OK;
struct virtio_scsi_inhdr *scsi = NULL; struct virtio_scsi_inhdr *scsi = NULL;
VirtIODevice *vdev = VIRTIO_DEVICE(blk);
#ifdef __linux__ #ifdef __linux__
int i; int i;
struct sg_io_hdr hdr; struct sg_io_hdr hdr;
@ -224,12 +228,12 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk,
hdr.status = CHECK_CONDITION; hdr.status = CHECK_CONDITION;
} }
stl_p(&scsi->errors, virtio_stl_p(vdev, &scsi->errors,
hdr.status | (hdr.msg_status << 8) | hdr.status | (hdr.msg_status << 8) |
(hdr.host_status << 16) | (hdr.driver_status << 24)); (hdr.host_status << 16) | (hdr.driver_status << 24));
stl_p(&scsi->residual, hdr.resid); virtio_stl_p(vdev, &scsi->residual, hdr.resid);
stl_p(&scsi->sense_len, hdr.sb_len_wr); virtio_stl_p(vdev, &scsi->sense_len, hdr.sb_len_wr);
stl_p(&scsi->data_len, hdr.dxfer_len); virtio_stl_p(vdev, &scsi->data_len, hdr.dxfer_len);
return status; return status;
#else #else
@ -239,7 +243,7 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk,
fail: fail:
/* Just put anything nonzero so that the ioctl fails in the guest. */ /* Just put anything nonzero so that the ioctl fails in the guest. */
if (scsi) { if (scsi) {
stl_p(&scsi->errors, 255); virtio_stl_p(vdev, &scsi->errors, 255);
} }
return status; return status;
} }
@ -289,7 +293,7 @@ static void virtio_blk_handle_write(VirtIOBlockReq *req, MultiReqBuffer *mrb)
BlockRequest *blkreq; BlockRequest *blkreq;
uint64_t sector; uint64_t sector;
sector = ldq_p(&req->out.sector); sector = virtio_ldq_p(VIRTIO_DEVICE(req->dev), &req->out.sector);
bdrv_acct_start(req->dev->bs, &req->acct, req->qiov.size, BDRV_ACCT_WRITE); bdrv_acct_start(req->dev->bs, &req->acct, req->qiov.size, BDRV_ACCT_WRITE);
@ -323,7 +327,7 @@ static void virtio_blk_handle_read(VirtIOBlockReq *req)
{ {
uint64_t sector; uint64_t sector;
sector = ldq_p(&req->out.sector); sector = virtio_ldq_p(VIRTIO_DEVICE(req->dev), &req->out.sector);
bdrv_acct_start(req->dev->bs, &req->acct, req->qiov.size, BDRV_ACCT_READ); bdrv_acct_start(req->dev->bs, &req->acct, req->qiov.size, BDRV_ACCT_READ);
@ -374,7 +378,7 @@ void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
- sizeof(struct virtio_blk_inhdr); - sizeof(struct virtio_blk_inhdr);
iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr)); iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
type = ldl_p(&req->out.type); type = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
if (type & VIRTIO_BLK_T_FLUSH) { if (type & VIRTIO_BLK_T_FLUSH) {
virtio_blk_handle_flush(req, mrb); virtio_blk_handle_flush(req, mrb);
@ -504,12 +508,12 @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
bdrv_get_geometry(s->bs, &capacity); bdrv_get_geometry(s->bs, &capacity);
memset(&blkcfg, 0, sizeof(blkcfg)); memset(&blkcfg, 0, sizeof(blkcfg));
stq_p(&blkcfg.capacity, capacity); virtio_stq_p(vdev, &blkcfg.capacity, capacity);
stl_p(&blkcfg.seg_max, 128 - 2); virtio_stl_p(vdev, &blkcfg.seg_max, 128 - 2);
stw_p(&blkcfg.cylinders, s->conf->cyls); virtio_stw_p(vdev, &blkcfg.cylinders, s->conf->cyls);
stl_p(&blkcfg.blk_size, blk_size); virtio_stl_p(vdev, &blkcfg.blk_size, blk_size);
stw_p(&blkcfg.min_io_size, s->conf->min_io_size / blk_size); virtio_stw_p(vdev, &blkcfg.min_io_size, s->conf->min_io_size / blk_size);
stw_p(&blkcfg.opt_io_size, s->conf->opt_io_size / blk_size); virtio_stw_p(vdev, &blkcfg.opt_io_size, s->conf->opt_io_size / blk_size);
blkcfg.heads = s->conf->heads; blkcfg.heads = s->conf->heads;
/* /*
* We must ensure that the block device capacity is a multiple of * We must ensure that the block device capacity is a multiple of