Patchwork [09/10] posix-aio-compat: Allow read after EOF

login
register
mail settings
Submitter Kevin Wolf
Date July 26, 2011, 11:49 a.m.
Message ID <1311680948-7648-10-git-send-email-kwolf@redhat.com>
Download mbox | patch
Permalink /patch/106868/
State New
Headers show

Comments

Kevin Wolf - July 26, 2011, 11:49 a.m.
In order to be able to transparently replace bdrv_read calls by bdrv_co_read,
reading beyond EOF must produce zeros instead of short reads for AIO, too.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 posix-aio-compat.c |   19 +++++++++++++++++++
 1 files changed, 19 insertions(+), 0 deletions(-)
Frediano Ziglio - July 26, 2011, 1:55 p.m.
2011/7/26 Kevin Wolf <kwolf@redhat.com>:
> In order to be able to transparently replace bdrv_read calls by bdrv_co_read,
> reading beyond EOF must produce zeros instead of short reads for AIO, too.
>
> Signed-off-by: Kevin Wolf <kwolf@redhat.com>
> ---
>  posix-aio-compat.c |   19 +++++++++++++++++++
>  1 files changed, 19 insertions(+), 0 deletions(-)
>
> diff --git a/posix-aio-compat.c b/posix-aio-compat.c
> index 788d113..8dc00cb 100644
> --- a/posix-aio-compat.c
> +++ b/posix-aio-compat.c
> @@ -198,6 +198,12 @@ static ssize_t handle_aiocb_rw_vector(struct qemu_paiocb *aiocb)
>     return len;
>  }
>
> +/*
> + * Read/writes the data to/from a given linear buffer.
> + *
> + * Returns the number of bytes handles or -errno in case of an error. Short
> + * reads are only returned if the end of the file is reached.
> + */
>  static ssize_t handle_aiocb_rw_linear(struct qemu_paiocb *aiocb, char *buf)
>  {
>     ssize_t offset = 0;
> @@ -334,6 +340,19 @@ static void *aio_thread(void *unused)
>
>         switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
>         case QEMU_AIO_READ:
> +            ret = handle_aiocb_rw(aiocb);
> +            if (ret >= 0 && ret < aiocb->aio_nbytes && aiocb->common.bs->growable) {
> +                /* A short read means that we have reached EOF. Pad the buffer
> +                 * with zeros for bytes after EOF. */
> +                QEMUIOVector qiov;
> +
> +                qemu_iovec_init_external(&qiov, aiocb->aio_iov,
> +                                         aiocb->aio_niov);
> +                qemu_iovec_memset_skip(&qiov, 0, aiocb->aio_nbytes - ret, ret);
> +
> +                ret = aiocb->aio_nbytes;
> +            }
> +            break;
>         case QEMU_AIO_WRITE:
>             ret = handle_aiocb_rw(aiocb);
>             break;
> --
> 1.7.6
>

Still not tested but I think to know what does it solve :)

I think Linux AIO require same attention.

Frediano
Kevin Wolf - July 26, 2011, 2:22 p.m.
Am 26.07.2011 15:55, schrieb Frediano Ziglio:
> 2011/7/26 Kevin Wolf <kwolf@redhat.com>:
>> In order to be able to transparently replace bdrv_read calls by bdrv_co_read,
>> reading beyond EOF must produce zeros instead of short reads for AIO, too.
>>
>> Signed-off-by: Kevin Wolf <kwolf@redhat.com>
>> ---
>>  posix-aio-compat.c |   19 +++++++++++++++++++
>>  1 files changed, 19 insertions(+), 0 deletions(-)
>>
>> diff --git a/posix-aio-compat.c b/posix-aio-compat.c
>> index 788d113..8dc00cb 100644
>> --- a/posix-aio-compat.c
>> +++ b/posix-aio-compat.c
>> @@ -198,6 +198,12 @@ static ssize_t handle_aiocb_rw_vector(struct qemu_paiocb *aiocb)
>>     return len;
>>  }
>>
>> +/*
>> + * Read/writes the data to/from a given linear buffer.
>> + *
>> + * Returns the number of bytes handles or -errno in case of an error. Short
>> + * reads are only returned if the end of the file is reached.
>> + */
>>  static ssize_t handle_aiocb_rw_linear(struct qemu_paiocb *aiocb, char *buf)
>>  {
>>     ssize_t offset = 0;
>> @@ -334,6 +340,19 @@ static void *aio_thread(void *unused)
>>
>>         switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
>>         case QEMU_AIO_READ:
>> +            ret = handle_aiocb_rw(aiocb);
>> +            if (ret >= 0 && ret < aiocb->aio_nbytes && aiocb->common.bs->growable) {
>> +                /* A short read means that we have reached EOF. Pad the buffer
>> +                 * with zeros for bytes after EOF. */
>> +                QEMUIOVector qiov;
>> +
>> +                qemu_iovec_init_external(&qiov, aiocb->aio_iov,
>> +                                         aiocb->aio_niov);
>> +                qemu_iovec_memset_skip(&qiov, 0, aiocb->aio_nbytes - ret, ret);
>> +
>> +                ret = aiocb->aio_nbytes;
>> +            }
>> +            break;
>>         case QEMU_AIO_WRITE:
>>             ret = handle_aiocb_rw(aiocb);
>>             break;
>> --
>> 1.7.6
>>
> 
> Still not tested but I think to know what does it solve :)
> 
> I think Linux AIO require same attention.

In theory yes, but it's not as easy and for some reason I couldn't
reproduce it with Linux AIO (maybe the problematic requests are
misaligned so that it falls back to posix-aio-compat.c), so I decided to
ignore it for now.

Patches are welcome. ;-)

Kevin

Patch

diff --git a/posix-aio-compat.c b/posix-aio-compat.c
index 788d113..8dc00cb 100644
--- a/posix-aio-compat.c
+++ b/posix-aio-compat.c
@@ -198,6 +198,12 @@  static ssize_t handle_aiocb_rw_vector(struct qemu_paiocb *aiocb)
     return len;
 }
 
+/*
+ * Read/writes the data to/from a given linear buffer.
+ *
+ * Returns the number of bytes handles or -errno in case of an error. Short
+ * reads are only returned if the end of the file is reached.
+ */
 static ssize_t handle_aiocb_rw_linear(struct qemu_paiocb *aiocb, char *buf)
 {
     ssize_t offset = 0;
@@ -334,6 +340,19 @@  static void *aio_thread(void *unused)
 
         switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
         case QEMU_AIO_READ:
+            ret = handle_aiocb_rw(aiocb);
+            if (ret >= 0 && ret < aiocb->aio_nbytes && aiocb->common.bs->growable) {
+                /* A short read means that we have reached EOF. Pad the buffer
+                 * with zeros for bytes after EOF. */
+                QEMUIOVector qiov;
+
+                qemu_iovec_init_external(&qiov, aiocb->aio_iov,
+                                         aiocb->aio_niov);
+                qemu_iovec_memset_skip(&qiov, 0, aiocb->aio_nbytes - ret, ret);
+
+                ret = aiocb->aio_nbytes;
+            }
+            break;
         case QEMU_AIO_WRITE:
             ret = handle_aiocb_rw(aiocb);
             break;