Skip to contentSkip to conversation

ide: avoid main-loop hang on CDROM/NFS failure

PATCH In review Peter Lieven 4 participants 16 messages Nov 12, 2015 – Nov 17, 2015 Block layer

lore
Share & tools
lore
#0 lore raw

v4 cover ide: avoid main-loop hang on CDROM/NFS failure

This series aims at avoiding a hanging main-loop if a vserver has a CDROM image mounted from a NFS share and that NFS share goes down. Typical situation is that users mount an CDROM ISO to install something and then forget to eject that CDROM afterwards.
As a consequence this mounted CD is able to bring down the whole vserver if the backend NFS share is unreachable. This is bad especially if the CDROM itself is not needed anymore at this point.

v3->v4: - Patch 1: remove buf argument for cd_read_sector{_sync}
- Patch 1: fix iov_base offset for 2352 sector size
- Patch 2: fix indent [Fam]
- Patch 3: fix leaking of req->iov.iov_base [Fam]

v2->v3: - adressed Stefans comments on Patch 1
- added patches 2,4,5,6
- avoided the term cancel in Patch 3. Added an iovec, added a BH [Stefan]
v1->v2: - fix offset for 2352 byte sector size [Kevin]
- use a sync request if we continue an elementary transfer. As John pointed out we enter a race condition between next IDE command and async transfer otherwise. This is sill not optimal, but it fixes the NFS down problems for all cases where the NFS server goes down while there is no PIO CD activity. Of course, it could still happen during a PIO transfer, but I expect this to be the unlikelier case.
I spent some effort trying to read more sectors at once and avoiding continuation of elementary transfers, but with whatever I came up it was destroying migration between different Qemu versions. I have a quite hackish patch that works and should survive migration, but I am not happy with it. So I would like to start with this version as it is a big improvement already.
- Dropped Patch 5 because it is upstream meanwhile.

Peter Lieven (6):
ide/atapi: make PIO read requests async
block: add blk_abort_aio_request
ide: add support for IDEBufferedRequest
ide: orphan all buffered requests on DMA cancel
ide: enable buffered requests for ATAPI devices
ide: enable buffered requests for PIO read requests

 block/block-backend.c          |  17 +++----
 hw/ide/atapi.c                 | 103 +++++++++++++++++++++++++++++++++++------
 hw/ide/core.c                  |  51 +++++++++++++++++++-
 hw/ide/internal.h              |  14 ++++++
 hw/ide/pci.c                   |  19 ++++++++
 include/sysemu/block-backend.h |   3 ++
 6 files changed, 182 insertions(+), 25 deletions(-)
Signature · 1 line
1.9.1
#1 lore raw

PATCH v4 1/6 ide/atapi: make PIO read requests async

PIO read requests on the ATAPI interface used to be sync blk requests. This has two significant drawbacks. First the main loop hangs util an I/O request is completed and secondly if the I/O request does not complete (e.g. due to an unresponsive storage) Qemu hangs completely.

Note: Due to possible race conditions requests during an ongoing elementary transfer are still sync.

---
 hw/ide/atapi.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 85 insertions(+), 12 deletions(-)
hw/ide/atapi.c +85 -12
index 747f466..cfd2d63 100644
@@ -105,33 +105,98 @@ static void cd_data_to_raw(uint8_t *buf, int lba)
     memset(buf, 0, 288);
 }
 
-static int cd_read_sector(IDEState *s, int lba, uint8_t *buf, int sector_size)
+static int
+cd_read_sector_sync(IDEState *s)
 {
     int ret;
 
-    switch(sector_size) {
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector_sync: lba=%d\n", s->lba);
+#endif
+
+    switch (s->cd_sector_size) {
     case 2048:
         block_acct_start(blk_get_stats(s->blk), &s->acct,
                          4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
-        ret = blk_read(s->blk, (int64_t)lba << 2, buf, 4);
+        ret = blk_read(s->blk, (int64_t)s->lba << 2,
+                       s->io_buffer, 4);
         block_acct_done(blk_get_stats(s->blk), &s->acct);
         break;
     case 2352:
         block_acct_start(blk_get_stats(s->blk), &s->acct,
                          4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
-        ret = blk_read(s->blk, (int64_t)lba << 2, buf + 16, 4);
+        ret = blk_read(s->blk, (int64_t)s->lba << 2,
+                       s->io_buffer + 16, 4);
         block_acct_done(blk_get_stats(s->blk), &s->acct);
         if (ret < 0)
             return ret;
-        cd_data_to_raw(buf, lba);
+        cd_data_to_raw(s->io_buffer, s->lba);
         break;
     default:
         ret = -EIO;
         break;
     }
+
+    if (!ret) {
+        s->lba++;
+        s->io_buffer_index = 0;
+    }
+
     return ret;
 }
 
+static void cd_read_sector_cb(void *opaque, int ret)
+{
+    IDEState *s = opaque;
+
+    block_acct_done(blk_get_stats(s->blk), &s->acct);
+
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector_cb: lba=%d ret=%d\n", s->lba, ret);
+#endif
+
+    if (ret < 0) {
+        ide_atapi_io_error(s, ret);
+        return;
+    }
+
+    if (s->cd_sector_size == 2352) {
+        cd_data_to_raw(s->io_buffer, s->lba);
+    }
+
+    s->lba++;
+    s->io_buffer_index = 0;
+    s->status &= ~BUSY_STAT;
+
+    ide_atapi_cmd_reply_end(s);
+}
+
+static int cd_read_sector(IDEState *s)
+{
+    if (s->cd_sector_size != 2048 && s->cd_sector_size != 2352) {
+        return -EINVAL;
+    }
+
+    s->iov.iov_base = (s->cd_sector_size == 2352) ?
+                      s->io_buffer + 16 : s->io_buffer;
+
+    s->iov.iov_len = 4 * BDRV_SECTOR_SIZE;
+    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
+
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector: lba=%d\n", s->lba);
+#endif
+
+    block_acct_start(blk_get_stats(s->blk), &s->acct,
+                     4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
+
+    blk_aio_readv(s->blk, (int64_t)s->lba << 2, &s->qiov, 4,
+                  cd_read_sector_cb, s);
+
+    s->status |= BUSY_STAT;
+    return 0;
+}
+
 void ide_atapi_cmd_ok(IDEState *s)
 {
     s->error = 0;
@@ -182,18 +247,27 @@ void ide_atapi_cmd_reply_end(IDEState *s)
         ide_atapi_cmd_ok(s);
         ide_set_irq(s->bus);
 #ifdef DEBUG_IDE_ATAPI
-        printf("status=0x%x\n", s->status);
+        printf("end of transfer, status=0x%x\n", s->status);
 #endif
     } else {
         /* see if a new sector must be read */
         if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
-            ret = cd_read_sector(s, s->lba, s->io_buffer, s->cd_sector_size);
-            if (ret < 0) {
-                ide_atapi_io_error(s, ret);
+            if (!s->elementary_transfer_size) {
+                ret = cd_read_sector(s);
+                if (ret < 0) {
+                    ide_atapi_io_error(s, ret);
+                }
                 return;
+            } else {
+                /* rebuffering within an elementary transfer is
+                 * only possible with a sync request because we
+                 * end up with a race condition otherwise */
+                ret = cd_read_sector_sync(s);
+                if (ret < 0) {
+                    ide_atapi_io_error(s, ret);
+                    return;
+                }
             }
-            s->lba++;
-            s->io_buffer_index = 0;
         }
         if (s->elementary_transfer_size > 0) {
             /* there are some data left to transmit in this elementary
@@ -275,7 +349,6 @@ static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
     s->io_buffer_index = sector_size;
     s->cd_sector_size = sector_size;
 
-    s->status = READY_STAT | SEEK_STAT;
     ide_atapi_cmd_reply_end(s);
 }
 
Signature · 1 line
1.9.1
Reviewed-by on v4 1/6
#2 lore raw

Re: [Qemu-devel] [PATCH V4 1/6] ide/atapi: make PIO read requests async

Quoted 157 lines · Peter Lieven

PIO read requests on the ATAPI interface used to be sync blk requests. This has two significant drawbacks. First the main loop hangs util an I/O request is completed and secondly if the I/O request does not complete (e.g. due to an unresponsive storage) Qemu hangs completely.

Note: Due to possible race conditions requests during an ongoing elementary transfer are still sync.

---
 hw/ide/atapi.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 85 insertions(+), 12 deletions(-)
hw/ide/atapi.c +85 -11
index 747f466..cfd2d63 100644
@@ -105,33 +105,98 @@ static void cd_data_to_raw(uint8_t *buf, int lba)
     memset(buf, 0, 288);
 }
 
-static int cd_read_sector(IDEState *s, int lba, uint8_t *buf, int sector_size)
+static int
+cd_read_sector_sync(IDEState *s)
 {
     int ret;
 
-    switch(sector_size) {
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector_sync: lba=%d\n", s->lba);
+#endif
+
+    switch (s->cd_sector_size) {
     case 2048:
         block_acct_start(blk_get_stats(s->blk), &s->acct,
                          4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
-        ret = blk_read(s->blk, (int64_t)lba << 2, buf, 4);
+        ret = blk_read(s->blk, (int64_t)s->lba << 2,
+                       s->io_buffer, 4);
         block_acct_done(blk_get_stats(s->blk), &s->acct);
         break;
     case 2352:
         block_acct_start(blk_get_stats(s->blk), &s->acct,
                          4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
-        ret = blk_read(s->blk, (int64_t)lba << 2, buf + 16, 4);
+        ret = blk_read(s->blk, (int64_t)s->lba << 2,
+                       s->io_buffer + 16, 4);
         block_acct_done(blk_get_stats(s->blk), &s->acct);
         if (ret < 0)
             return ret;
-        cd_data_to_raw(buf, lba);
+        cd_data_to_raw(s->io_buffer, s->lba);
         break;
     default:
         ret = -EIO;
         break;
     }
+
+    if (!ret) {
+        s->lba++;
+        s->io_buffer_index = 0;
+    }
+
     return ret;
 }
 
+static void cd_read_sector_cb(void *opaque, int ret)
+{
+    IDEState *s = opaque;
+
+    block_acct_done(blk_get_stats(s->blk), &s->acct);
+
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector_cb: lba=%d ret=%d\n", s->lba, ret);
+#endif
+
+    if (ret < 0) {
+        ide_atapi_io_error(s, ret);
+        return;
+    }
+
+    if (s->cd_sector_size == 2352) {
+        cd_data_to_raw(s->io_buffer, s->lba);
+    }
+
+    s->lba++;
+    s->io_buffer_index = 0;
+    s->status &= ~BUSY_STAT;
+
+    ide_atapi_cmd_reply_end(s);
+}
+
+static int cd_read_sector(IDEState *s)
+{
+    if (s->cd_sector_size != 2048 && s->cd_sector_size != 2352) {
+        return -EINVAL;
+    }
+
+    s->iov.iov_base = (s->cd_sector_size == 2352) ?
+                      s->io_buffer + 16 : s->io_buffer;
+
+    s->iov.iov_len = 4 * BDRV_SECTOR_SIZE;
+    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
+
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector: lba=%d\n", s->lba);
+#endif
+
+    block_acct_start(blk_get_stats(s->blk), &s->acct,
+                     4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
+
+    blk_aio_readv(s->blk, (int64_t)s->lba << 2, &s->qiov, 4,
+                  cd_read_sector_cb, s);
+
+    s->status |= BUSY_STAT;
+    return 0;
+}
+
 void ide_atapi_cmd_ok(IDEState *s)
 {
     s->error = 0;
@@ -182,18 +247,27 @@ void ide_atapi_cmd_reply_end(IDEState *s)
         ide_atapi_cmd_ok(s);
         ide_set_irq(s->bus);
 #ifdef DEBUG_IDE_ATAPI
-        printf("status=0x%x\n", s->status);
+        printf("end of transfer, status=0x%x\n", s->status);
 #endif
     } else {
         /* see if a new sector must be read */
         if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
-            ret = cd_read_sector(s, s->lba, s->io_buffer, s->cd_sector_size);
-            if (ret < 0) {
-                ide_atapi_io_error(s, ret);
+            if (!s->elementary_transfer_size) {
+                ret = cd_read_sector(s);
+                if (ret < 0) {
+                    ide_atapi_io_error(s, ret);
+                }
                 return;
+            } else {
+                /* rebuffering within an elementary transfer is
+                 * only possible with a sync request because we
+                 * end up with a race condition otherwise */
+                ret = cd_read_sector_sync(s);
+                if (ret < 0) {
+                    ide_atapi_io_error(s, ret);
+                    return;
+                }
             }
-            s->lba++;
-            s->io_buffer_index = 0;
         }
         if (s->elementary_transfer_size > 0) {
             /* there are some data left to transmit in this elementary

hw/ide/atapi.c static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors, · line 354

Quoted 7 lines
hw/ide/atapi.c +0 -1
@@ -275,7 +349,6 @@ static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
     s->io_buffer_index = sector_size;
     s->cd_sector_size = sector_size;
 
-    s->status = READY_STAT | SEEK_STAT;
     ide_atapi_cmd_reply_end(s);
 }
 

Had to rebase against Berto's patches, but nothing major. You can see my rebase at:

https://github.com/jnsnow/qemu/tree/review-plieven

#3 lore raw

Re: [Qemu-devel] [PATCH V4 1/6] ide/atapi: make PIO read requests async

Quoted 173 lines

Am 13.11.2015 um 23:42 schrieb John Snow <[email protected]>:

Quoted 157 lines · Peter Lieven

PIO read requests on the ATAPI interface used to be sync blk requests. This has two significant drawbacks. First the main loop hangs util an I/O request is completed and secondly if the I/O request does not complete (e.g. due to an unresponsive storage) Qemu hangs completely.

Note: Due to possible race conditions requests during an ongoing elementary transfer are still sync.

---
hw/ide/atapi.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++--------

1 file changed, 85 insertions(+), 12 deletions(-)
hw/ide/atapi.c +85 -11
index 747f466..cfd2d63 100644
@@ -105,33 +105,98 @@ static void cd_data_to_raw(uint8_t *buf, int lba)
    memset(buf, 0, 288);
 }
 
-static int cd_read_sector(IDEState *s, int lba, uint8_t *buf, int sector_size)
+static int
+cd_read_sector_sync(IDEState *s)
 {
    int ret;
 
-    switch(sector_size) {
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector_sync: lba=%d\n", s->lba);
+#endif
+
+    switch (s->cd_sector_size) {
    case 2048:
        block_acct_start(blk_get_stats(s->blk), &s->acct,
                         4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
-        ret = blk_read(s->blk, (int64_t)lba << 2, buf, 4);
+        ret = blk_read(s->blk, (int64_t)s->lba << 2,
+                       s->io_buffer, 4);
        block_acct_done(blk_get_stats(s->blk), &s->acct);
        break;
    case 2352:
        block_acct_start(blk_get_stats(s->blk), &s->acct,
                         4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
-        ret = blk_read(s->blk, (int64_t)lba << 2, buf + 16, 4);
+        ret = blk_read(s->blk, (int64_t)s->lba << 2,
+                       s->io_buffer + 16, 4);
        block_acct_done(blk_get_stats(s->blk), &s->acct);
        if (ret < 0)
            return ret;
-        cd_data_to_raw(buf, lba);
+        cd_data_to_raw(s->io_buffer, s->lba);
        break;
    default:
        ret = -EIO;
        break;
    }
+
+    if (!ret) {
+        s->lba++;
+        s->io_buffer_index = 0;
+    }
+
    return ret;
 }
 
+static void cd_read_sector_cb(void *opaque, int ret)
+{
+    IDEState *s = opaque;
+
+    block_acct_done(blk_get_stats(s->blk), &s->acct);
+
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector_cb: lba=%d ret=%d\n", s->lba, ret);
+#endif
+
+    if (ret < 0) {
+        ide_atapi_io_error(s, ret);
+        return;
+    }
+
+    if (s->cd_sector_size == 2352) {
+        cd_data_to_raw(s->io_buffer, s->lba);
+    }
+
+    s->lba++;
+    s->io_buffer_index = 0;
+    s->status &= ~BUSY_STAT;
+
+    ide_atapi_cmd_reply_end(s);
+}
+
+static int cd_read_sector(IDEState *s)
+{
+    if (s->cd_sector_size != 2048 && s->cd_sector_size != 2352) {
+        return -EINVAL;
+    }
+
+    s->iov.iov_base = (s->cd_sector_size == 2352) ?
+                      s->io_buffer + 16 : s->io_buffer;
+
+    s->iov.iov_len = 4 * BDRV_SECTOR_SIZE;
+    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
+
+#ifdef DEBUG_IDE_ATAPI
+    printf("cd_read_sector: lba=%d\n", s->lba);
+#endif
+
+    block_acct_start(blk_get_stats(s->blk), &s->acct,
+                     4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
+
+    blk_aio_readv(s->blk, (int64_t)s->lba << 2, &s->qiov, 4,
+                  cd_read_sector_cb, s);
+
+    s->status |= BUSY_STAT;
+    return 0;
+}
+
 void ide_atapi_cmd_ok(IDEState *s)
 {
    s->error = 0;
@@ -182,18 +247,27 @@ void ide_atapi_cmd_reply_end(IDEState *s)
        ide_atapi_cmd_ok(s);
        ide_set_irq(s->bus);
 #ifdef DEBUG_IDE_ATAPI
-        printf("status=0x%x\n", s->status);
+        printf("end of transfer, status=0x%x\n", s->status);
 #endif
    } else {
        /* see if a new sector must be read */
        if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
-            ret = cd_read_sector(s, s->lba, s->io_buffer, s->cd_sector_size);
-            if (ret < 0) {
-                ide_atapi_io_error(s, ret);
+            if (!s->elementary_transfer_size) {
+                ret = cd_read_sector(s);
+                if (ret < 0) {
+                    ide_atapi_io_error(s, ret);
+                }
                return;
+            } else {
+                /* rebuffering within an elementary transfer is
+                 * only possible with a sync request because we
+                 * end up with a race condition otherwise */
+                ret = cd_read_sector_sync(s);
+                if (ret < 0) {
+                    ide_atapi_io_error(s, ret);
+                    return;
+                }
            }
-            s->lba++;
-            s->io_buffer_index = 0;
        }
        if (s->elementary_transfer_size > 0) {
            /* there are some data left to transmit in this elementary

hw/ide/atapi.c static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors, · line 353

Quoted 6 lines
hw/ide/atapi.c +0 -1
@@ -275,7 +349,6 @@ static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
    s->io_buffer_index = sector_size;
    s->cd_sector_size = sector_size;
 
-    s->status = READY_STAT | SEEK_STAT;
    ide_atapi_cmd_reply_end(s);
 }

Had to rebase against Berto's patches, but nothing major. You can see my rebase at:

Quoted 3 lines

https://github.com/jnsnow/qemu/tree/review-plieven

in Patch 1 the indent is off at the end. Otherwise looks good to me.

Peter

#4 lore raw

PATCH v4 2/6 block: add blk_abort_aio_request

In reply to Peter Lieven
---
 block/block-backend.c          | 17 +++++++++--------
 include/sysemu/block-backend.h |  3 +++
 2 files changed, 12 insertions(+), 8 deletions(-)
block/block-backend.c +9 -8
index 6f9309f..701234e 100644
@@ -641,8 +641,9 @@ static void error_callback_bh(void *opaque)
     qemu_aio_unref(acb);
 }
 
-static BlockAIOCB *abort_aio_request(BlockBackend *blk, BlockCompletionFunc *cb,
-                                     void *opaque, int ret)
+BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
+                                  BlockCompletionFunc *cb,
+                                  void *opaque, int ret)
 {
     struct BlockBackendAIOCB *acb;
     QEMUBH *bh;
@@ -664,7 +665,7 @@ BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num,
 {
     int ret = blk_check_request(blk, sector_num, nb_sectors);
     if (ret < 0) {
-        return abort_aio_request(blk, cb, opaque, ret);
+        return blk_abort_aio_request(blk, cb, opaque, ret);
     }
 
     return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags,
@@ -724,7 +725,7 @@ BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
 {
     int ret = blk_check_request(blk, sector_num, nb_sectors);
     if (ret < 0) {
-        return abort_aio_request(blk, cb, opaque, ret);
+        return blk_abort_aio_request(blk, cb, opaque, ret);
     }
 
     return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
@@ -736,7 +737,7 @@ BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
 {
     int ret = blk_check_request(blk, sector_num, nb_sectors);
     if (ret < 0) {
-        return abort_aio_request(blk, cb, opaque, ret);
+        return blk_abort_aio_request(blk, cb, opaque, ret);
     }
 
     return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
@@ -746,7 +747,7 @@ BlockAIOCB *blk_aio_flush(BlockBackend *blk,
                           BlockCompletionFunc *cb, void *opaque)
 {
     if (!blk_is_available(blk)) {
-        return abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
+        return blk_abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
     }
 
     return bdrv_aio_flush(blk->bs, cb, opaque);
@@ -758,7 +759,7 @@ BlockAIOCB *blk_aio_discard(BlockBackend *blk,
 {
     int ret = blk_check_request(blk, sector_num, nb_sectors);
     if (ret < 0) {
-        return abort_aio_request(blk, cb, opaque, ret);
+        return blk_abort_aio_request(blk, cb, opaque, ret);
     }
 
     return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque);
@@ -801,7 +802,7 @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
                           BlockCompletionFunc *cb, void *opaque)
 {
     if (!blk_is_available(blk)) {
-        return abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
+        return blk_abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
     }
 
     return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque);
include/sysemu/block-backend.h +3 -0
index f4a68e2..fb068ea4 100644
@@ -184,5 +184,8 @@ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size);
 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz);
 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo);
+BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
+                                  BlockCompletionFunc *cb,
+                                  void *opaque, int ret);
 
 #endif
Signature · 1 line
1.9.1
#5 lore raw

PATCH v4 3/6 ide: add support for IDEBufferedRequest

In reply to Peter Lieven

this patch adds a new aio readv compatible function which copies all data through a bounce buffer. These buffered requests can be flagged as orphaned which means that their original callback has already been invoked and the request has just not been completed by the backend storage. The bounce buffer guarantees that guest memory corruption is avoided when such a orphaned request is completed by the backend at a later stage.

This trick only works for read requests as a write request completed at a later stage might corrupt data as there is no way to control if and what data has already been written to the storage.

---
 hw/ide/core.c     | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 hw/ide/internal.h | 14 ++++++++++++++
 2 files changed, 61 insertions(+)
hw/ide/core.c +47 -0
index 364ba21..7ca67bc 100644
@@ -561,6 +561,53 @@ static bool ide_sect_range_ok(IDEState *s,
     return true;
 }
 
+static void ide_buffered_readv_cb(void *opaque, int ret)
+{
+    IDEBufferedRequest *req = opaque;
+    if (!req->orphaned) {
+        if (!ret) {
+            qemu_iovec_from_buf(req->original_qiov, 0, req->iov.iov_base,
+                                req->original_qiov->size);
+        }
+        req->original_cb(req->original_opaque, ret);
+    }
+    QLIST_REMOVE(req, list);
+    qemu_vfree(req->iov.iov_base);
+    g_free(req);
+}
+
+#define MAX_BUFFERED_REQS 16
+
+BlockAIOCB *ide_buffered_readv(IDEState *s, int64_t sector_num,
+                               QEMUIOVector *iov, int nb_sectors,
+                               BlockCompletionFunc *cb, void *opaque)
+{
+    BlockAIOCB *aioreq;
+    IDEBufferedRequest *req;
+    int c = 0;
+
+    QLIST_FOREACH(req, &s->buffered_requests, list) {
+        c++;
+    }
+    if (c > MAX_BUFFERED_REQS) {
+        return blk_abort_aio_request(s->blk, cb, opaque, -EIO);
+    }
+
+    req = g_new0(IDEBufferedRequest, 1);
+    req->original_qiov = iov;
+    req->original_cb = cb;
+    req->original_opaque = opaque;
+    req->iov.iov_base = qemu_blockalign(blk_bs(s->blk), iov->size);
+    req->iov.iov_len = iov->size;
+    qemu_iovec_init_external(&req->qiov, &req->iov, 1);
+
+    aioreq = blk_aio_readv(s->blk, sector_num, &req->qiov, nb_sectors,
+                           ide_buffered_readv_cb, req);
+
+    QLIST_INSERT_HEAD(&s->buffered_requests, req, list);
+    return aioreq;
+}
+
 static void ide_sector_read(IDEState *s);
 
 static void ide_sector_read_cb(void *opaque, int ret)
hw/ide/internal.h +14 -0
index e4629b0..2d1e2d2 100644
@@ -343,6 +343,16 @@ enum ide_dma_cmd {
 #define ide_cmd_is_read(s) \
 	((s)->dma_cmd == IDE_DMA_READ)
 
+typedef struct IDEBufferedRequest {
+    QLIST_ENTRY(IDEBufferedRequest) list;
+    struct iovec iov;
+    QEMUIOVector qiov;
+    QEMUIOVector *original_qiov;
+    BlockCompletionFunc *original_cb;
+    void *original_opaque;
+    bool orphaned;
+} IDEBufferedRequest;
+
 /* NOTE: IDEState represents in fact one drive */
 struct IDEState {
     IDEBus *bus;
@@ -396,6 +406,7 @@ struct IDEState {
     BlockAIOCB *pio_aiocb;
     struct iovec iov;
     QEMUIOVector qiov;
+    QLIST_HEAD(, IDEBufferedRequest) buffered_requests;
     /* ATA DMA state */
     uint64_t io_buffer_offset;
     int32_t io_buffer_size;
@@ -572,6 +583,9 @@ void ide_set_inactive(IDEState *s, bool more);
 BlockAIOCB *ide_issue_trim(BlockBackend *blk,
         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
         BlockCompletionFunc *cb, void *opaque);
+BlockAIOCB *ide_buffered_readv(IDEState *s, int64_t sector_num,
+                               QEMUIOVector *iov, int nb_sectors,
+                               BlockCompletionFunc *cb, void *opaque);
 
 /* hw/ide/atapi.c */
 void ide_atapi_cmd(IDEState *s);
Signature · 1 line
1.9.1
#6 lore raw

PATCH v4 4/6 ide: orphan all buffered requests on DMA cancel

In reply to Peter Lieven

If the guests canceles a DMA request we can prematurely invoke all callbacks of buffered requests and flag all them as orphaned. Ideally this avoids the need for draining all requests. For CDROM devices this works in 100% of all cases.

---
 hw/ide/pci.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
hw/ide/pci.c +19 -0
index 9c54b37..37dbc29 100644
@@ -233,6 +233,22 @@ void bmdma_cmd_writeb(BMDMAState *bm, uint32_t val)
     /* Ignore writes to SSBM if it keeps the old value */
     if ((val & BM_CMD_START) != (bm->cmd & BM_CMD_START)) {
         if (!(val & BM_CMD_START)) {
+            /* First invoke the callbacks of all buffered requests
+             * and flag those requests as orphaned. Ideally there
+             * are no unbuffered (Scatter Gather DMA Requests or
+             * write requests) pending and we can avoid to drain. */
+            IDEBufferedRequest *req;
+            IDEState *s = idebus_active_if(bm->bus);
+            QLIST_FOREACH(req, &s->buffered_requests, list) {
+                if (!req->orphaned) {
+#ifdef DEBUG_IDE
+                    printf("%s: invoking cb %p of buffered request %p with"
+                           " -ECANCELED\n", __func__, req->original_cb, req);
+#endif
+                    req->original_cb(req->original_opaque, -ECANCELED);
+                }
+                req->orphaned = true;
+            }
             /*
              * We can't cancel Scatter Gather DMA in the middle of the
              * operation or a partial (not full) DMA transfer would reach
@@ -246,6 +262,9 @@ void bmdma_cmd_writeb(BMDMAState *bm, uint32_t val)
              * aio operation with preadv/pwritev.
              */
             if (bm->bus->dma->aiocb) {
+#ifdef DEBUG_IDE
+                printf("%s: draining all remaining requests", __func__);
+#endif
                 blk_drain_all();
                 assert(bm->bus->dma->aiocb == NULL);
             }
Signature · 1 line
1.9.1
#7 lore raw

PATCH v4 5/6 ide: enable buffered requests for ATAPI devices

In reply to Peter Lieven
---
 hw/ide/atapi.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)
hw/ide/atapi.c +5 -5
index cfd2d63..d1eaa29 100644
@@ -190,8 +190,8 @@ static int cd_read_sector(IDEState *s)
     block_acct_start(blk_get_stats(s->blk), &s->acct,
                      4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
 
-    blk_aio_readv(s->blk, (int64_t)s->lba << 2, &s->qiov, 4,
-                  cd_read_sector_cb, s);
+    ide_buffered_readv(s, (int64_t)s->lba << 2, &s->qiov, 4,
+                       cd_read_sector_cb, s);
 
     s->status |= BUSY_STAT;
     return 0;
@@ -424,9 +424,9 @@ static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
     s->bus->dma->iov.iov_len = n * 4 * 512;
     qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
 
-    s->bus->dma->aiocb = blk_aio_readv(s->blk, (int64_t)s->lba << 2,
-                                       &s->bus->dma->qiov, n * 4,
-                                       ide_atapi_cmd_read_dma_cb, s);
+    s->bus->dma->aiocb = ide_buffered_readv(s, (int64_t)s->lba << 2,
+                                            &s->bus->dma->qiov, n * 4,
+                                            ide_atapi_cmd_read_dma_cb, s);
     return;
 
 eot:
Signature · 1 line
1.9.1
#8 lore raw

PATCH v4 6/6 ide: enable buffered requests for PIO read requests

In reply to Peter Lieven
---
 hw/ide/core.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
hw/ide/core.c +2 -2
index 7ca67bc..b9b531c 100644
@@ -677,8 +677,8 @@ static void ide_sector_read(IDEState *s)
 
     block_acct_start(blk_get_stats(s->blk), &s->acct,
                      n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
-    s->pio_aiocb = blk_aio_readv(s->blk, sector_num, &s->qiov, n,
-                                 ide_sector_read_cb, s);
+    s->pio_aiocb = ide_buffered_readv(s, sector_num, &s->qiov, n,
+                                      ide_sector_read_cb, s);
 }
 
 void dma_buf_commit(IDEState *s, uint32_t tx_bytes)
Signature · 1 line
1.9.1
#9 lore raw
In reply to Peter Lieven
Quoted 42 lines · Peter Lieven

This series aims at avoiding a hanging main-loop if a vserver has a CDROM image mounted from a NFS share and that NFS share goes down. Typical situation is that users mount an CDROM ISO to install something and then forget to eject that CDROM afterwards.
As a consequence this mounted CD is able to bring down the whole vserver if the backend NFS share is unreachable. This is bad especially if the CDROM itself is not needed anymore at this point.

v3->v4: - Patch 1: remove buf argument for cd_read_sector{_sync}
- Patch 1: fix iov_base offset for 2352 sector size
- Patch 2: fix indent [Fam]
- Patch 3: fix leaking of req->iov.iov_base [Fam]

v2->v3: - adressed Stefans comments on Patch 1
- added patches 2,4,5,6
- avoided the term cancel in Patch 3. Added an iovec, added a BH [Stefan]
v1->v2: - fix offset for 2352 byte sector size [Kevin]
- use a sync request if we continue an elementary transfer. As John pointed out we enter a race condition between next IDE command and async transfer otherwise. This is sill not optimal, but it fixes the NFS down problems for all cases where the NFS server goes down while there is no PIO CD activity. Of course, it could still happen during a PIO transfer, but I expect this to be the unlikelier case.
I spent some effort trying to read more sectors at once and avoiding continuation of elementary transfers, but with whatever I came up it was destroying migration between different Qemu versions. I have a quite hackish patch that works and should survive migration, but I am not happy with it. So I would like to start with this version as it is a big improvement already.
- Dropped Patch 5 because it is upstream meanwhile.

Peter Lieven (6):
ide/atapi: make PIO read requests async
block: add blk_abort_aio_request
ide: add support for IDEBufferedRequest
ide: orphan all buffered requests on DMA cancel
ide: enable buffered requests for ATAPI devices
ide: enable buffered requests for PIO read requests

Quoted 7 lines
 block/block-backend.c          |  17 +++----
 hw/ide/atapi.c                 | 103 +++++++++++++++++++++++++++++++++++------
 hw/ide/core.c                  |  51 +++++++++++++++++++-
 hw/ide/internal.h              |  14 ++++++
 hw/ide/pci.c                   |  19 ++++++++
 include/sysemu/block-backend.h |   3 ++
 6 files changed, 182 insertions(+), 25 deletions(-)

Patches 4-6 look like they may handle issues I've found with migration in DMA requests on PPC g3beige and mac99 machines. Unfortunately due to alignment issues, the macio controller has implement its own versions of some of these routines, so should parts of these also be applied hw/ide/macio.c aswell?

ATB,

Mark.

#10 lore raw
Quoted 59 lines · Mark Cave-Ayland
Quoted 42 lines · Peter Lieven

This series aims at avoiding a hanging main-loop if a vserver has a CDROM image mounted from a NFS share and that NFS share goes down. Typical situation is that users mount an CDROM ISO to install something and then forget to eject that CDROM afterwards.
As a consequence this mounted CD is able to bring down the whole vserver if the backend NFS share is unreachable. This is bad especially if the CDROM itself is not needed anymore at this point.

v3->v4: - Patch 1: remove buf argument for cd_read_sector{_sync}
- Patch 1: fix iov_base offset for 2352 sector size
- Patch 2: fix indent [Fam]
- Patch 3: fix leaking of req->iov.iov_base [Fam]

v2->v3: - adressed Stefans comments on Patch 1
- added patches 2,4,5,6
- avoided the term cancel in Patch 3. Added an iovec, added a BH [Stefan]
v1->v2: - fix offset for 2352 byte sector size [Kevin]
- use a sync request if we continue an elementary transfer. As John pointed out we enter a race condition between next IDE command and async transfer otherwise. This is sill not optimal, but it fixes the NFS down problems for all cases where the NFS server goes down while there is no PIO CD activity. Of course, it could still happen during a PIO transfer, but I expect this to be the unlikelier case.
I spent some effort trying to read more sectors at once and avoiding continuation of elementary transfers, but with whatever I came up it was destroying migration between different Qemu versions. I have a quite hackish patch that works and should survive migration, but I am not happy with it. So I would like to start with this version as it is a big improvement already.
- Dropped Patch 5 because it is upstream meanwhile.

Peter Lieven (6):
ide/atapi: make PIO read requests async
block: add blk_abort_aio_request
ide: add support for IDEBufferedRequest
ide: orphan all buffered requests on DMA cancel
ide: enable buffered requests for ATAPI devices
ide: enable buffered requests for PIO read requests

Quoted 7 lines
 block/block-backend.c          |  17 +++----
 hw/ide/atapi.c                 | 103 +++++++++++++++++++++++++++++++++++------
 hw/ide/core.c                  |  51 +++++++++++++++++++-
 hw/ide/internal.h              |  14 ++++++
 hw/ide/pci.c                   |  19 ++++++++
 include/sysemu/block-backend.h |   3 ++
 6 files changed, 182 insertions(+), 25 deletions(-)

Patches 4-6 look like they may handle issues I've found with migration in DMA requests on PPC g3beige and mac99 machines. Unfortunately due to alignment issues, the macio controller has implement its own versions of some of these routines, so should parts of these also be applied hw/ide/macio.c aswell?

Quoted 4 lines

ATB,

Mark.

I still might be suffering delusions that I can sneak this into 2.5 -- I wouldn't mind reworking this to share with macio later if that's the case.

I don't think I'll make acceptance of this patchset conditional on macio inclusion either way, though.

--js

Reviewed-by on the v4 series
#11 lore raw
In reply to Peter Lieven
Quoted 42 lines · Peter Lieven

This series aims at avoiding a hanging main-loop if a vserver has a CDROM image mounted from a NFS share and that NFS share goes down. Typical situation is that users mount an CDROM ISO to install something and then forget to eject that CDROM afterwards.
As a consequence this mounted CD is able to bring down the whole vserver if the backend NFS share is unreachable. This is bad especially if the CDROM itself is not needed anymore at this point.

v3->v4: - Patch 1: remove buf argument for cd_read_sector{_sync}
- Patch 1: fix iov_base offset for 2352 sector size
- Patch 2: fix indent [Fam]
- Patch 3: fix leaking of req->iov.iov_base [Fam]

v2->v3: - adressed Stefans comments on Patch 1
- added patches 2,4,5,6
- avoided the term cancel in Patch 3. Added an iovec, added a BH [Stefan]
v1->v2: - fix offset for 2352 byte sector size [Kevin]
- use a sync request if we continue an elementary transfer. As John pointed out we enter a race condition between next IDE command and async transfer otherwise. This is sill not optimal, but it fixes the NFS down problems for all cases where the NFS server goes down while there is no PIO CD activity. Of course, it could still happen during a PIO transfer, but I expect this to be the unlikelier case.
I spent some effort trying to read more sectors at once and avoiding continuation of elementary transfers, but with whatever I came up it was destroying migration between different Qemu versions. I have a quite hackish patch that works and should survive migration, but I am not happy with it. So I would like to start with this version as it is a big improvement already.
- Dropped Patch 5 because it is upstream meanwhile.

Peter Lieven (6):
ide/atapi: make PIO read requests async
block: add blk_abort_aio_request
ide: add support for IDEBufferedRequest
ide: orphan all buffered requests on DMA cancel
ide: enable buffered requests for ATAPI devices
ide: enable buffered requests for PIO read requests

Quoted 8 lines
 block/block-backend.c          |  17 +++----
 hw/ide/atapi.c                 | 103 +++++++++++++++++++++++++++++++++++------
 hw/ide/core.c                  |  51 +++++++++++++++++++-
 hw/ide/internal.h              |  14 ++++++
 hw/ide/pci.c                   |  19 ++++++++
 include/sysemu/block-backend.h |   3 ++
 6 files changed, 182 insertions(+), 25 deletions(-)

It looks sane to me:

Fam, Stefan: Do you think this is still sane for 2.5? I am inclined to get it in as a fix, especially since we've been bouncing it around for so long.

--js

#12 lore raw
Quoted 54 lines · John Snow
Quoted 42 lines · Peter Lieven

This series aims at avoiding a hanging main-loop if a vserver has a CDROM image mounted from a NFS share and that NFS share goes down. Typical situation is that users mount an CDROM ISO to install something and then forget to eject that CDROM afterwards.
As a consequence this mounted CD is able to bring down the whole vserver if the backend NFS share is unreachable. This is bad especially if the CDROM itself is not needed anymore at this point.

v3->v4: - Patch 1: remove buf argument for cd_read_sector{_sync}
- Patch 1: fix iov_base offset for 2352 sector size
- Patch 2: fix indent [Fam]
- Patch 3: fix leaking of req->iov.iov_base [Fam]

v2->v3: - adressed Stefans comments on Patch 1
- added patches 2,4,5,6
- avoided the term cancel in Patch 3. Added an iovec, added a BH [Stefan]
v1->v2: - fix offset for 2352 byte sector size [Kevin]
- use a sync request if we continue an elementary transfer. As John pointed out we enter a race condition between next IDE command and async transfer otherwise. This is sill not optimal, but it fixes the NFS down problems for all cases where the NFS server goes down while there is no PIO CD activity. Of course, it could still happen during a PIO transfer, but I expect this to be the unlikelier case.
I spent some effort trying to read more sectors at once and avoiding continuation of elementary transfers, but with whatever I came up it was destroying migration between different Qemu versions. I have a quite hackish patch that works and should survive migration, but I am not happy with it. So I would like to start with this version as it is a big improvement already.
- Dropped Patch 5 because it is upstream meanwhile.

Peter Lieven (6):
ide/atapi: make PIO read requests async
block: add blk_abort_aio_request
ide: add support for IDEBufferedRequest
ide: orphan all buffered requests on DMA cancel
ide: enable buffered requests for ATAPI devices
ide: enable buffered requests for PIO read requests

Quoted 8 lines
 block/block-backend.c          |  17 +++----
 hw/ide/atapi.c                 | 103 +++++++++++++++++++++++++++++++++++------
 hw/ide/core.c                  |  51 +++++++++++++++++++-
 hw/ide/internal.h              |  14 ++++++
 hw/ide/pci.c                   |  19 ++++++++
 include/sysemu/block-backend.h |   3 ++
 6 files changed, 182 insertions(+), 25 deletions(-)
Quoted 7 lines

It looks sane to me:

Fam, Stefan: Do you think this is still sane for 2.5? I am inclined to get it in as a fix, especially since we've been bouncing it around for so long.

I have no objection here, there is no new feature in the series, and guest hanging right after installing something is admittedly annoying to users.

Thanks,
Fam

#13 lore raw

Am 16.11.2015 um 07:17 schrieb Fam Zheng:

Quoted 55 lines · John Snow
Quoted 54 lines · Peter Lieven
Quoted 42 lines

This series aims at avoiding a hanging main-loop if a vserver has a CDROM image mounted from a NFS share and that NFS share goes down. Typical situation is that users mount an CDROM ISO to install something and then forget to eject that CDROM afterwards.
As a consequence this mounted CD is able to bring down the whole vserver if the backend NFS share is unreachable. This is bad especially if the CDROM itself is not needed anymore at this point.

v3->v4: - Patch 1: remove buf argument for cd_read_sector{_sync}
- Patch 1: fix iov_base offset for 2352 sector size
- Patch 2: fix indent [Fam]
- Patch 3: fix leaking of req->iov.iov_base [Fam]

v2->v3: - adressed Stefans comments on Patch 1
- added patches 2,4,5,6
- avoided the term cancel in Patch 3. Added an iovec, added a BH [Stefan]
v1->v2: - fix offset for 2352 byte sector size [Kevin]
- use a sync request if we continue an elementary transfer. As John pointed out we enter a race condition between next IDE command and async transfer otherwise. This is sill not optimal, but it fixes the NFS down problems for all cases where the NFS server goes down while there is no PIO CD activity. Of course, it could still happen during a PIO transfer, but I expect this to be the unlikelier case.
I spent some effort trying to read more sectors at once and avoiding continuation of elementary transfers, but with whatever I came up it was destroying migration between different Qemu versions. I have a quite hackish patch that works and should survive migration, but I am not happy with it. So I would like to start with this version as it is a big improvement already.
- Dropped Patch 5 because it is upstream meanwhile.

Peter Lieven (6):
ide/atapi: make PIO read requests async
block: add blk_abort_aio_request
ide: add support for IDEBufferedRequest
ide: orphan all buffered requests on DMA cancel
ide: enable buffered requests for ATAPI devices
ide: enable buffered requests for PIO read requests

Quoted 8 lines
  block/block-backend.c          |  17 +++----
  hw/ide/atapi.c                 | 103 +++++++++++++++++++++++++++++++++++------
  hw/ide/core.c                  |  51 +++++++++++++++++++-
  hw/ide/internal.h              |  14 ++++++
  hw/ide/pci.c                   |  19 ++++++++
  include/sysemu/block-backend.h |   3 ++
  6 files changed, 182 insertions(+), 25 deletions(-)

It looks sane to me:

Quoted 7 lines
Quoted 5 lines

Fam, Stefan: Do you think this is still sane for 2.5? I am inclined to get it in as a fix, especially since we've been bouncing it around for so long.

I have no objection here, there is no new feature in the series, and guest hanging right after installing something is admittedly annoying to users.

Thats for speaking for merging it in 2.5. However, I have to clarify that the fixed behaviour is the same since day 1 of Qemu.

Peter

#14 lore raw
In reply to Fam Zheng
Quoted 63 lines · Fam Zheng
Quoted 54 lines · John Snow
Quoted 42 lines · Peter Lieven

This series aims at avoiding a hanging main-loop if a vserver has a CDROM image mounted from a NFS share and that NFS share goes down. Typical situation is that users mount an CDROM ISO to install something and then forget to eject that CDROM afterwards.
As a consequence this mounted CD is able to bring down the whole vserver if the backend NFS share is unreachable. This is bad especially if the CDROM itself is not needed anymore at this point.

v3->v4: - Patch 1: remove buf argument for cd_read_sector{_sync}
- Patch 1: fix iov_base offset for 2352 sector size
- Patch 2: fix indent [Fam]
- Patch 3: fix leaking of req->iov.iov_base [Fam]

v2->v3: - adressed Stefans comments on Patch 1
- added patches 2,4,5,6
- avoided the term cancel in Patch 3. Added an iovec, added a BH [Stefan]
v1->v2: - fix offset for 2352 byte sector size [Kevin]
- use a sync request if we continue an elementary transfer. As John pointed out we enter a race condition between next IDE command and async transfer otherwise. This is sill not optimal, but it fixes the NFS down problems for all cases where the NFS server goes down while there is no PIO CD activity. Of course, it could still happen during a PIO transfer, but I expect this to be the unlikelier case.
I spent some effort trying to read more sectors at once and avoiding continuation of elementary transfers, but with whatever I came up it was destroying migration between different Qemu versions. I have a quite hackish patch that works and should survive migration, but I am not happy with it. So I would like to start with this version as it is a big improvement already.
- Dropped Patch 5 because it is upstream meanwhile.

Peter Lieven (6):
ide/atapi: make PIO read requests async
block: add blk_abort_aio_request
ide: add support for IDEBufferedRequest
ide: orphan all buffered requests on DMA cancel
ide: enable buffered requests for ATAPI devices
ide: enable buffered requests for PIO read requests

Quoted 8 lines
 block/block-backend.c          |  17 +++----
 hw/ide/atapi.c                 | 103 +++++++++++++++++++++++++++++++++++------
 hw/ide/core.c                  |  51 +++++++++++++++++++-
 hw/ide/internal.h              |  14 ++++++
 hw/ide/pci.c                   |  19 ++++++++
 include/sysemu/block-backend.h |   3 ++
 6 files changed, 182 insertions(+), 25 deletions(-)
Quoted 7 lines

It looks sane to me:

Fam, Stefan: Do you think this is still sane for 2.5? I am inclined to get it in as a fix, especially since we've been bouncing it around for so long.

Quoted 6 lines

I have no objection here, there is no new feature in the series, and guest hanging right after installing something is admittedly annoying to users.

Thanks,
Fam

I will send a PR. Fam, should I add your R-B?

--js

Reviewed-by
#15 lore raw
Quoted 11 lines · John Snow
Quoted 11 lines
Quoted 7 lines

It looks sane to me:

Fam, Stefan: Do you think this is still sane for 2.5? I am inclined to get it in as a fix, especially since we've been bouncing it around for so long.

I have no objection here, there is no new feature in the series, and guest hanging right after installing something is admittedly annoying to users.

Quoted 7 lines
Quoted 3 lines

Thanks,
Fam

I will send a PR. Fam, should I add your R-B?

--js

For patches 2-6: