diff mbox

[2/2] virtio-blk: fix length calculations for write operations.

Message ID 1426053572-21326-3-git-send-email-rusty@rustcorp.com.au
State New
Headers show

Commit Message

Rusty Russell March 11, 2015, 5:59 a.m. UTC
We only fill in the 'req->qiov.size' bytes on a (successful) read,
not on a write.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
---
 hw/block/virtio-blk.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

Comments

Michael S. Tsirkin March 11, 2015, 6:48 a.m. UTC | #1
On Wed, Mar 11, 2015 at 04:29:32PM +1030, Rusty Russell wrote:
> We only fill in the 'req->qiov.size' bytes on a (successful) read,
> not on a write.
> 
> Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
> ---
>  hw/block/virtio-blk.c | 10 +++++++++-
>  1 file changed, 9 insertions(+), 1 deletion(-)
> 
> diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
> index 258bb4c..98d87a9 100644
> --- a/hw/block/virtio-blk.c
> +++ b/hw/block/virtio-blk.c
> @@ -50,11 +50,19 @@ static void virtio_blk_complete_request(VirtIOBlockReq *req,
>  {
>      VirtIOBlock *s = req->dev;
>      VirtIODevice *vdev = VIRTIO_DEVICE(s);
> +    int type = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
>  
>      trace_virtio_blk_req_complete(req, status);
>  
>      stb_p(&req->in->status, status);
> -    virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
> +
> +    /* If we didn't succeed, we *may* have written more, but don't
> +     * count on it. */

I wonder about this.
So length as you specify it is <= actually written length.
What are the advantages of this approach?
How about we do the reverse, specify that the length in descriptor
is >= the size actually written?

If we do this, all these buggy hosts suddenly become correct,
which seems better.


> +    if (type == VIRTIO_BLK_T_IN && status == VIRTIO_BLK_S_OK) {
> +        virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
> +    } else {
> +        virtqueue_push(s->vq, &req->elem, sizeof(*req->in));
> +    }
>      virtio_notify(vdev, s->vq);
>  }
>  
> -- 
> 2.1.0
Rusty Russell March 11, 2015, 11:34 a.m. UTC | #2
"Michael S. Tsirkin" <mst@redhat.com> writes:
> On Wed, Mar 11, 2015 at 04:29:32PM +1030, Rusty Russell wrote:
>> We only fill in the 'req->qiov.size' bytes on a (successful) read,
>> not on a write.
>> 
>> Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
>> ---
>>  hw/block/virtio-blk.c | 10 +++++++++-
>>  1 file changed, 9 insertions(+), 1 deletion(-)
>> 
>> diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
>> index 258bb4c..98d87a9 100644
>> --- a/hw/block/virtio-blk.c
>> +++ b/hw/block/virtio-blk.c
>> @@ -50,11 +50,19 @@ static void virtio_blk_complete_request(VirtIOBlockReq *req,
>>  {
>>      VirtIOBlock *s = req->dev;
>>      VirtIODevice *vdev = VIRTIO_DEVICE(s);
>> +    int type = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
>>  
>>      trace_virtio_blk_req_complete(req, status);
>>  
>>      stb_p(&req->in->status, status);
>> -    virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
>> +
>> +    /* If we didn't succeed, we *may* have written more, but don't
>> +     * count on it. */
>
> I wonder about this.
> So length as you specify it is <= actually written length.
> What are the advantages of this approach?
> How about we do the reverse, specify that the length in descriptor
> is >= the size actually written?
>
> If we do this, all these buggy hosts suddenly become correct,
> which seems better.

The point of telling the guest the amount written is that they don't
have to zero the receive buffer beforehand.

Cheers,
Rusty.
diff mbox

Patch

diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index 258bb4c..98d87a9 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -50,11 +50,19 @@  static void virtio_blk_complete_request(VirtIOBlockReq *req,
 {
     VirtIOBlock *s = req->dev;
     VirtIODevice *vdev = VIRTIO_DEVICE(s);
+    int type = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
 
     trace_virtio_blk_req_complete(req, status);
 
     stb_p(&req->in->status, status);
-    virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
+
+    /* If we didn't succeed, we *may* have written more, but don't
+     * count on it. */
+    if (type == VIRTIO_BLK_T_IN && status == VIRTIO_BLK_S_OK) {
+        virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
+    } else {
+        virtqueue_push(s->vq, &req->elem, sizeof(*req->in));
+    }
     virtio_notify(vdev, s->vq);
 }