[Qemu-devel] [PULL 0/6] Block patches

[Qemu-devel] [PULL 0/6] Block patches

[Kevin Wolf]

The following changes since commit 5933e8a96ab9c59cb6b6c80c9db385364a68c959:

  fix last cpu timer initialization (2010-08-02 18:49:13 +0000)

are available in the git repository at:
  git://repo.or.cz/qemu/kevin.git for-anthony

Andrea Arcangeli (1):
      ide: Avoid canceling IDE DMA

Kevin Wolf (2):
      block: Change bdrv_commit to handle multiple sectors at once
      block: Fix bdrv_has_zero_init

Markus Armbruster (1):
      block: Change bdrv_eject() not to drop the image

Miguel Di Ciurcio Filho (1):
      loadvm: improve tests before bdrv_snapshot_goto()

Yoshiaki Tamura (1):
      block migration: replace tabs by spaces.

 block-migration.c |   12 ++++----
 block.c           |   50 ++++++++++++++++++------------------
 block/raw-posix.c |   13 ++++++---
 block/raw-win32.c |    6 ++++
 block/raw.c       |    6 ++++
 block_int.h       |    8 ++++-
 hw/ide/pci.c      |   23 +++++++++++++++-
 monitor.c         |    3 +-
 savevm.c          |   71 +++++++++++++++++++++++++---------------------------
 9 files changed, 115 insertions(+), 77 deletions(-)

[Qemu-devel] [PATCH 1/6] block: Change bdrv_commit to handle multiple sectors at once

[Kevin Wolf]

bdrv_commit copies the image to its backing file sector by sector, which
is (surprise!) relatively slow. Let's take a larger buffer and handle more
sectors at once if possible.

With a 1G qcow2 file, this brought the time bdrv_commit takes down from
5:06 min to 1:14 min for me.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c |   39 ++++++++++++++++++++-------------------
 1 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/block.c b/block.c
index 452ae94..c4d6814 100644
--- a/block.c
+++ b/block.c
@@ -739,14 +739,16 @@ int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
     return bs->drv->bdrv_check(bs, res);
 }
 
+#define COMMIT_BUF_SECTORS 2048
+
 /* commit COW file into the raw image */
 int bdrv_commit(BlockDriverState *bs)
 {
     BlockDriver *drv = bs->drv;
-    int64_t i, total_sectors;
-    int n, j, ro, open_flags;
+    int64_t sector, total_sectors;
+    int n, ro, open_flags;
     int ret = 0, rw_ret = 0;
-    unsigned char sector[BDRV_SECTOR_SIZE];
+    uint8_t *buf;
     char filename[1024];
     BlockDriverState *bs_rw, *bs_ro;
 
@@ -789,22 +791,20 @@ int bdrv_commit(BlockDriverState *bs)
     }
 
     total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
-    for (i = 0; i < total_sectors;) {
-        if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
-            for(j = 0; j < n; j++) {
-                if (bdrv_read(bs, i, sector, 1) != 0) {
-                    ret = -EIO;
-                    goto ro_cleanup;
-                }
+    buf = qemu_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
 
-                if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
-                    ret = -EIO;
-                    goto ro_cleanup;
-                }
-                i++;
-	    }
-	} else {
-            i += n;
+    for (sector = 0; sector < total_sectors; sector += n) {
+        if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
+
+            if (bdrv_read(bs, sector, buf, n) != 0) {
+                ret = -EIO;
+                goto ro_cleanup;
+            }
+
+            if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
+                ret = -EIO;
+                goto ro_cleanup;
+            }
         }
     }
 
@@ -821,6 +821,7 @@ int bdrv_commit(BlockDriverState *bs)
         bdrv_flush(bs->backing_hd);
 
 ro_cleanup:
+    qemu_free(buf);
 
     if (ro) {
         /* re-open as RO */
-- 
1.7.2

[Qemu-devel] [PATCH 2/6] loadvm: improve tests before bdrv_snapshot_goto()

[Kevin Wolf]

From: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>

This patch improves the resilience of the load_vmstate() function, doing
further and better ordered tests.

In load_vmstate(), if there is any error on bdrv_snapshot_goto(), except if the
error is on VM state device, load_vmstate() will return zero and the VM will be
started with major corruption chances.

The current process:
- test if there is any writable device without snapshot support
    - if exists return -error
- get the device that saves the VM state, possible return -error but unlikely
because it was tested earlier
- flush I/O
- run bdrv_snapshot_goto() on devices
    - if fails, give an warning and goes to the next (not good!)
    - if fails on the VM state device, return zero (not good!)
- check if the requested snapshot exists on the device that saves the VM state
and the state is not zero
    - if fails return -error
- open the file with the VM state
    - if fails return -error
- load the VM state
    - if fails return -error
- return zero

New behavior:
- get the device that saves the VM state
    - if fails return -error
- check if the requested snapshot exists on the device that saves the VM state
and the state is not zero
    - if fails return -error
- test if there is any writable device without snapshot support
    - if exists return -error
- test if the devices with snapshot support have the requested snapshot
    - if anyone fails, return -error
- flush I/O
- run snapshot_goto() on devices
    - if anyone fails, return -error
- open the file with the VM state
    - if fails return -error
- load the VM state
    - if fails return -error
- return zero

do_loadvm must not call vm_start if any error has occurred in load_vmstate.

Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 monitor.c |    3 +-
 savevm.c  |   71 +++++++++++++++++++++++++++++-------------------------------
 2 files changed, 36 insertions(+), 38 deletions(-)

diff --git a/monitor.c b/monitor.c
index 5366c36..c313d5a 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2274,8 +2274,9 @@ static void do_loadvm(Monitor *mon, const QDict *qdict)
 
     vm_stop(0);
 
-    if (load_vmstate(name) >= 0 && saved_vm_running)
+    if (load_vmstate(name) == 0 && saved_vm_running) {
         vm_start();
+    }
 }
 
 int monitor_get_fd(Monitor *mon, const char *fdname)
diff --git a/savevm.c b/savevm.c
index 4c0e5d3..53d47a6 100644
--- a/savevm.c
+++ b/savevm.c
@@ -1894,12 +1894,27 @@ void do_savevm(Monitor *mon, const QDict *qdict)
 
 int load_vmstate(const char *name)
 {
-    BlockDriverState *bs, *bs1;
+    BlockDriverState *bs, *bs_vm_state;
     QEMUSnapshotInfo sn;
     QEMUFile *f;
     int ret;
 
-    /* Verify if there is a device that doesn't support snapshots and is writable */
+    bs_vm_state = bdrv_snapshots();
+    if (!bs_vm_state) {
+        error_report("No block device supports snapshots");
+        return -ENOTSUP;
+    }
+
+    /* Don't even try to load empty VM states */
+    ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
+    if (ret < 0) {
+        return ret;
+    } else if (sn.vm_state_size == 0) {
+        return -EINVAL;
+    }
+
+    /* Verify if there is any device that doesn't support snapshots and is
+    writable and check if the requested snapshot is available too. */
     bs = NULL;
     while ((bs = bdrv_next(bs))) {
 
@@ -1912,63 +1927,45 @@ int load_vmstate(const char *name)
                                bdrv_get_device_name(bs));
             return -ENOTSUP;
         }
-    }
 
-    bs = bdrv_snapshots();
-    if (!bs) {
-        error_report("No block device supports snapshots");
-        return -EINVAL;
+        ret = bdrv_snapshot_find(bs, &sn, name);
+        if (ret < 0) {
+            error_report("Device '%s' does not have the requested snapshot '%s'",
+                           bdrv_get_device_name(bs), name);
+            return ret;
+        }
     }
 
     /* Flush all IO requests so they don't interfere with the new state.  */
     qemu_aio_flush();
 
-    bs1 = NULL;
-    while ((bs1 = bdrv_next(bs1))) {
-        if (bdrv_can_snapshot(bs1)) {
-            ret = bdrv_snapshot_goto(bs1, name);
+    bs = NULL;
+    while ((bs = bdrv_next(bs))) {
+        if (bdrv_can_snapshot(bs)) {
+            ret = bdrv_snapshot_goto(bs, name);
             if (ret < 0) {
-                switch(ret) {
-                case -ENOTSUP:
-                    error_report("%sSnapshots not supported on device '%s'",
-                                 bs != bs1 ? "Warning: " : "",
-                                 bdrv_get_device_name(bs1));
-                    break;
-                case -ENOENT:
-                    error_report("%sCould not find snapshot '%s' on device '%s'",
-                                 bs != bs1 ? "Warning: " : "",
-                                 name, bdrv_get_device_name(bs1));
-                    break;
-                default:
-                    error_report("%sError %d while activating snapshot on '%s'",
-                                 bs != bs1 ? "Warning: " : "",
-                                 ret, bdrv_get_device_name(bs1));
-                    break;
-                }
-                /* fatal on snapshot block device */
-                if (bs == bs1)
-                    return 0;
+                error_report("Error %d while activating snapshot '%s' on '%s'",
+                             ret, name, bdrv_get_device_name(bs));
+                return ret;
             }
         }
     }
 
-    /* Don't even try to load empty VM states */
-    ret = bdrv_snapshot_find(bs, &sn, name);
-    if ((ret >= 0) && (sn.vm_state_size == 0))
-        return -EINVAL;
-
     /* restore the VM state */
-    f = qemu_fopen_bdrv(bs, 0);
+    f = qemu_fopen_bdrv(bs_vm_state, 0);
     if (!f) {
         error_report("Could not open VM state file");
         return -EINVAL;
     }
+
     ret = qemu_loadvm_state(f);
+
     qemu_fclose(f);
     if (ret < 0) {
         error_report("Error %d while loading VM state", ret);
         return ret;
     }
+
     return 0;
 }
 
-- 
1.7.2

[Qemu-devel] [PATCH 3/6] block migration: replace tabs by spaces.

[Kevin Wolf]

From: Yoshiaki Tamura <tamura.yoshiaki@lab.ntt.co.jp>

Signed-off-by: Yoshiaki Tamura <tamura.yoshiaki@lab.ntt.co.jp>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block-migration.c |   12 ++++++------
 1 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/block-migration.c b/block-migration.c
index 8eda307..0bfdb73 100644
--- a/block-migration.c
+++ b/block-migration.c
@@ -346,7 +346,7 @@ static int mig_save_device_dirty(Monitor *mon, QEMUFile *f,
                 blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
                 qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
 
-		blk->time = qemu_get_clock_ns(rt_clock);
+                blk->time = qemu_get_clock_ns(rt_clock);
 
                 blk->aiocb = bdrv_aio_readv(bmds->bs, sector, &blk->qiov,
                                             nr_sectors, blk_mig_read_cb, blk);
@@ -449,13 +449,13 @@ static int is_stage2_completed(void)
     if (block_mig_state.bulk_completed == 1) {
 
         remaining_dirty = get_remaining_dirty();
-	if (remaining_dirty == 0) {
-	    return 1;
-	}
+        if (remaining_dirty == 0) {
+            return 1;
+        }
 
-	bwidth = compute_read_bwidth();
+        bwidth = compute_read_bwidth();
 
-	if ((remaining_dirty / bwidth) <=
+        if ((remaining_dirty / bwidth) <=
             migrate_max_downtime()) {
             /* finish stage2 because we think that we can finish remaing work
                below max_downtime */
-- 
1.7.2

[Qemu-devel] [PATCH 4/6] block: Fix bdrv_has_zero_init

[Kevin Wolf]

Assuming that any image on a block device is not properly zero-initialized is
actually wrong: Only raw images have this problem. Any other image format
shouldn't care about it, they initialize everything properly themselves.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c           |    6 ++----
 block/raw-posix.c |   13 +++++++++----
 block/raw-win32.c |    6 ++++++
 block/raw.c       |    6 ++++++
 block_int.h       |    7 +++++--
 5 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/block.c b/block.c
index c4d6814..a12be0b 100644
--- a/block.c
+++ b/block.c
@@ -1477,10 +1477,8 @@ int bdrv_has_zero_init(BlockDriverState *bs)
 {
     assert(bs->drv);
 
-    if (bs->drv->no_zero_init) {
-        return 0;
-    } else if (bs->file) {
-        return bdrv_has_zero_init(bs->file);
+    if (bs->drv->bdrv_has_zero_init) {
+        return bs->drv->bdrv_has_zero_init(bs);
     }
 
     return 1;
diff --git a/block/raw-posix.c b/block/raw-posix.c
index a11170e..72fb8ce 100644
--- a/block/raw-posix.c
+++ b/block/raw-posix.c
@@ -993,6 +993,11 @@ static int hdev_create(const char *filename, QEMUOptionParameter *options)
     return ret;
 }
 
+static int hdev_has_zero_init(BlockDriverState *bs)
+{
+    return 0;
+}
+
 static BlockDriver bdrv_host_device = {
     .format_name        = "host_device",
     .protocol_name        = "host_device",
@@ -1002,7 +1007,7 @@ static BlockDriver bdrv_host_device = {
     .bdrv_close         = raw_close,
     .bdrv_create        = hdev_create,
     .create_options     = raw_create_options,
-    .no_zero_init       = 1,
+    .bdrv_has_zero_init = hdev_has_zero_init,
     .bdrv_flush         = raw_flush,
 
     .bdrv_aio_readv	= raw_aio_readv,
@@ -1117,7 +1122,7 @@ static BlockDriver bdrv_host_floppy = {
     .bdrv_close         = raw_close,
     .bdrv_create        = hdev_create,
     .create_options     = raw_create_options,
-    .no_zero_init       = 1,
+    .bdrv_has_zero_init = hdev_has_zero_init,
     .bdrv_flush         = raw_flush,
 
     .bdrv_aio_readv     = raw_aio_readv,
@@ -1217,7 +1222,7 @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_close         = raw_close,
     .bdrv_create        = hdev_create,
     .create_options     = raw_create_options,
-    .no_zero_init       = 1,
+    .bdrv_has_zero_init = hdev_has_zero_init,
     .bdrv_flush         = raw_flush,
 
     .bdrv_aio_readv     = raw_aio_readv,
@@ -1340,7 +1345,7 @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_close         = raw_close,
     .bdrv_create        = hdev_create,
     .create_options     = raw_create_options,
-    .no_zero_init       = 1,
+    .bdrv_has_zero_init = hdev_has_zero_init,
     .bdrv_flush         = raw_flush,
 
     .bdrv_aio_readv     = raw_aio_readv,
diff --git a/block/raw-win32.c b/block/raw-win32.c
index 745bbde..503ed39 100644
--- a/block/raw-win32.c
+++ b/block/raw-win32.c
@@ -394,6 +394,11 @@ static int raw_set_locked(BlockDriverState *bs, int locked)
 }
 #endif
 
+static int hdev_has_zero_init(BlockDriverState *bs)
+{
+    return 0;
+}
+
 static BlockDriver bdrv_host_device = {
     .format_name	= "host_device",
     .protocol_name	= "host_device",
@@ -402,6 +407,7 @@ static BlockDriver bdrv_host_device = {
     .bdrv_file_open	= hdev_open,
     .bdrv_close		= raw_close,
     .bdrv_flush		= raw_flush,
+    .bdrv_has_zero_init = hdev_has_zero_init,
 
     .bdrv_read		= raw_read,
     .bdrv_write	        = raw_write,
diff --git a/block/raw.c b/block/raw.c
index 1414e77..61e6748 100644
--- a/block/raw.c
+++ b/block/raw.c
@@ -237,6 +237,11 @@ static QEMUOptionParameter raw_create_options[] = {
     { NULL }
 };
 
+static int raw_has_zero_init(BlockDriverState *bs)
+{
+    return bdrv_has_zero_init(bs->file);
+}
+
 static BlockDriver bdrv_raw = {
     .format_name        = "raw",
 
@@ -264,6 +269,7 @@ static BlockDriver bdrv_raw = {
 
     .bdrv_create        = raw_create,
     .create_options     = raw_create_options,
+    .bdrv_has_zero_init = raw_has_zero_init,
 };
 
 static void bdrv_raw_init(void)
diff --git a/block_int.h b/block_int.h
index f075a8c..7d5e751 100644
--- a/block_int.h
+++ b/block_int.h
@@ -127,8 +127,11 @@ struct BlockDriver {
 
     void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event);
 
-    /* Set if newly created images are not guaranteed to contain only zeros */
-    int no_zero_init;
+    /*
+     * Returns 1 if newly created images are guaranteed to contain only
+     * zeros, 0 otherwise.
+     */
+    int (*bdrv_has_zero_init)(BlockDriverState *bs);
 
     QLIST_ENTRY(BlockDriver) list;
 };
-- 
1.7.2

[Qemu-devel] [PATCH 5/6] block: Change bdrv_eject() not to drop the image

[Kevin Wolf]

From: Markus Armbruster <armbru@redhat.com>

bdrv_eject() gets called when a device model opens or closes the tray.

If the block driver implements method bdrv_eject(), that method gets
called.  Drivers host_cdrom implements it, and it opens and closes the
physical tray, and nothing else.  When a device model opens, then
closes the tray, media changes only if the user actively changes the
physical media while the tray is open.  This is matches how physical
hardware behaves.

If the block driver doesn't implement method bdrv_eject(), we do
something quite different: opening the tray severs the connection to
the image by calling bdrv_close(), and closing the tray does nothing.
When the device model opens, then closes the tray, media is gone,
unless the user actively inserts another one while the tray is open,
with a suitable change command in the monitor.  This isn't how
physical hardware behaves.  Rather inconvenient when programs
"helpfully" eject media to give you a chance to change it.  The way
bdrv_eject() behaves here turns that chance into a must, which is not
what these programs or their users expect.

Change the default action not to call bdrv_close().  Instead, note the
tray status in new BlockDriverState member tray_open.  Use it in
bdrv_is_inserted().

Arguably, the device models should keep track of tray status
themselves.  But this is less invasive.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c     |    7 ++++---
 block_int.h |    1 +
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/block.c b/block.c
index a12be0b..da70f29 100644
--- a/block.c
+++ b/block.c
@@ -2517,7 +2517,7 @@ int bdrv_is_inserted(BlockDriverState *bs)
     if (!drv)
         return 0;
     if (!drv->bdrv_is_inserted)
-        return 1;
+        return !bs->tray_open;
     ret = drv->bdrv_is_inserted(bs);
     return ret;
 }
@@ -2559,10 +2559,11 @@ int bdrv_eject(BlockDriverState *bs, int eject_flag)
         ret = drv->bdrv_eject(bs, eject_flag);
     }
     if (ret == -ENOTSUP) {
-        if (eject_flag)
-            bdrv_close(bs);
         ret = 0;
     }
+    if (ret >= 0) {
+        bs->tray_open = eject_flag;
+    }
 
     return ret;
 }
diff --git a/block_int.h b/block_int.h
index 7d5e751..b863451 100644
--- a/block_int.h
+++ b/block_int.h
@@ -144,6 +144,7 @@ struct BlockDriverState {
     int open_flags; /* flags used to open the file, re-used for re-open */
     int removable; /* if true, the media can be removed */
     int locked;    /* if true, the media cannot temporarily be ejected */
+    int tray_open; /* if true, the virtual tray is open */
     int encrypted; /* if true, the media is encrypted */
     int valid_key; /* if true, a valid encryption key has been set */
     int sg;        /* if true, the device is a /dev/sg* */
-- 
1.7.2

[Qemu-devel] [PATCH 6/6] ide: Avoid canceling IDE DMA

[Kevin Wolf]

From: Andrea Arcangeli <aarcange@redhat.com>

The reason for not actually canceling the I/O is because with
virtualization and lots of VM running, a guest fs may mistake a
overload of the host, as an IDE timeout. So rather than canceling the
I/O, it's safer to wait I/O completion and simulate that the I/O has
completed just before the io cancellation was requested by the
guest. This way if ntfs or an app writes data without checking for
-EIO retval, and it thinks the write has succeeded, it's less likely
to run into troubles. Similar issues for reads.

Furthermore because the DMA operation is splitted into many synchronous
aio_read/write if there's more than one entry in the SG table, without this
patch the DMA would be cancelled in the middle, something we've no idea if it
happens on real hardware too or not. Overall this seems a great risk for zero
gain.

This approach is sure safer than previous code given we can't pretend all guest
fs code out there to check for errors and reply the DMA if it was completed
partially, given a timeout would never materialize on a real harddisk unless
there are defective blocks (and defective blocks are practically only an issue
for reads never for writes in any recent hardware as writing to blocks is the
way to fix them) or the harddisk breaks as a whole.

Signed-off-by: Izik Eidus <ieidus@redhat.com>
Signed-off-by: Andrea Arcangeli <aarcange@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/ide/pci.c |   23 +++++++++++++++++++++--
 1 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/hw/ide/pci.c b/hw/ide/pci.c
index 4331d77..ec90f26 100644
--- a/hw/ide/pci.c
+++ b/hw/ide/pci.c
@@ -40,8 +40,27 @@ void bmdma_cmd_writeb(void *opaque, uint32_t addr, uint32_t val)
     printf("%s: 0x%08x\n", __func__, val);
 #endif
     if (!(val & BM_CMD_START)) {
-        /* XXX: do it better */
-        ide_dma_cancel(bm);
+        /*
+         * We can't cancel Scatter Gather DMA in the middle of the
+         * operation or a partial (not full) DMA transfer would reach
+         * the storage so we wait for completion instead (we beahve
+         * like if the DMA was completed by the time the guest trying
+         * to cancel dma with bmdma_cmd_writeb with BM_CMD_START not
+         * set).
+         *
+         * In the future we'll be able to safely cancel the I/O if the
+         * whole DMA operation will be submitted to disk with a single
+         * aio operation with preadv/pwritev.
+         */
+        if (bm->aiocb) {
+            qemu_aio_flush();
+#ifdef DEBUG_IDE
+            if (bm->aiocb)
+                printf("ide_dma_cancel: aiocb still pending");
+            if (bm->status & BM_STATUS_DMAING)
+                printf("ide_dma_cancel: BM_STATUS_DMAING still pending");
+#endif
+        }
         bm->cmd = val & 0x09;
     } else {
         if (!(bm->status & BM_STATUS_DMAING)) {
-- 
1.7.2

Re: [Qemu-devel] [PULL 0/6] Block patches

[Anthony Liguori]

On 08/03/2010 09:44 AM, Kevin Wolf wrote:
> The following changes since commit 5933e8a96ab9c59cb6b6c80c9db385364a68c959:
>
>    fix last cpu timer initialization (2010-08-02 18:49:13 +0000)
>    

Pulled, thanks.

Regards,

Anthony Liguori

> are available in the git repository at:
>    git://repo.or.cz/qemu/kevin.git for-anthony
>
> Andrea Arcangeli (1):
>        ide: Avoid canceling IDE DMA
>
> Kevin Wolf (2):
>        block: Change bdrv_commit to handle multiple sectors at once
>        block: Fix bdrv_has_zero_init
>
> Markus Armbruster (1):
>        block: Change bdrv_eject() not to drop the image
>
> Miguel Di Ciurcio Filho (1):
>        loadvm: improve tests before bdrv_snapshot_goto()
>
> Yoshiaki Tamura (1):
>        block migration: replace tabs by spaces.
>
>   block-migration.c |   12 ++++----
>   block.c           |   50 ++++++++++++++++++------------------
>   block/raw-posix.c |   13 ++++++---
>   block/raw-win32.c |    6 ++++
>   block/raw.c       |    6 ++++
>   block_int.h       |    8 ++++-
>   hw/ide/pci.c      |   23 +++++++++++++++-
>   monitor.c         |    3 +-
>   savevm.c          |   71 +++++++++++++++++++++++++---------------------------
>   9 files changed, 115 insertions(+), 77 deletions(-)
>
>
>    

Re: [Qemu-devel] [PATCH 6/6] ide: Avoid canceling IDE DMA

[Christoph Hellwig]

On Tue, Aug 03, 2010 at 04:44:30PM +0200, Kevin Wolf wrote:
> Furthermore because the DMA operation is splitted into many synchronous
> aio_read/write if there's more than one entry in the SG table, without this
> patch the DMA would be cancelled in the middle, something we've no idea if it
> happens on real hardware too or not. Overall this seems a great risk for zero
> gain.

That hasn't been true for a long time when this code was commited, at least
on kernel supporting preadv/pwritev and/or aio.

Re: [Qemu-devel] [PATCH 6/6] ide: Avoid canceling IDE DMA

[Kevin Wolf]

Am 18.03.2011 12:19, schrieb Christoph Hellwig:
> On Tue, Aug 03, 2010 at 04:44:30PM +0200, Kevin Wolf wrote:
>> Furthermore because the DMA operation is splitted into many synchronous
>> aio_read/write if there's more than one entry in the SG table, without this
>> patch the DMA would be cancelled in the middle, something we've no idea if it
>> happens on real hardware too or not. Overall this seems a great risk for zero
>> gain.
> 
> That hasn't been true for a long time when this code was commited, at least
> on kernel supporting preadv/pwritev and/or aio.

So what do you want to tell us? Should the patch be reverted?

I think the request can still be split in multiple bdrv_aio_readv/writev
calls in dma-helpers.c and in non-raw block drivers, so we would still
cancel somewhere in the middle.

Kevin

Re: [Qemu-devel] [PATCH 6/6] ide: Avoid canceling IDE DMA

[Christoph Hellwig]

On Fri, Mar 18, 2011 at 12:34:09PM +0100, Kevin Wolf wrote:
> > That hasn't been true for a long time when this code was commited, at least
> > on kernel supporting preadv/pwritev and/or aio.
> 
> So what do you want to tell us? Should the patch be reverted?

Just looked into that area for a bug reported and noticed the comment,
which at least should be corrected.  To be honest I don't quite
understand the point of this commit at all, but maybe Andrea can explain
it a bit more.

[Qemu-devel] [BUG] Re: [2/6] loadvm: improve tests before bdrv_snapshot_goto()

[Philipp Hahn]

[-- Attachment #1: Type: text/plain, Size: 2148 bytes --]

Hello,

Am Dienstag 03 August 2010 06:44:26 schrieb Kevin Wolf:
> From: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
>
> This patch improves the resilience of the load_vmstate() function, doing
> further and better ordered tests.

This patch broke restoring not-running VMs using libvirt-0.8.7 with qemu-0.14: 
When the domain is not running while taking a snpshot, the sn.vm_state_size 
== 0:

2021        } else if (sn.vm_state_size == 0) {
(gdb) print sn
$6 = {id_str = "1", '\0' <repeats 126 times>, name = "pre-update-flash", '\0' 
<repeats 239 times>, vm_state_size = 0, date_sec = 1302698007, date_nsec = 
711909000, 
  vm_clock_nsec = 0}

> The [old] process:
...
> - run bdrv_snapshot_goto() on devices
>     - if fails, give an warning and goes to the next (not good!)
>     - if fails on the VM state device, return zero (not good!)
> - check if the requested snapshot exists on the device that saves the VM
> state and the state is not zero
>     - if fails return -error

Previously the qcow2 image was still reverted to the old state, so on the next 
start of the domain the qcow2 image would be in the state of the snapshot

> New behavior:
...
> - check if the requested snapshot exists on the device that saves the VM
> state and the state is not zero
>     - if fails return -error
...
> - run snapshot_goto() on devices

Now the qcow2 image is not reverted and when the domain is started, it is NOT 
in the state of the snapshot.

I can't decide if this regression is an Qemu bug or libvirt should be adapted 
to this new behavior.

I found the Bug also reported with Ubuntu and created a Bug in our own German 
bugtracker:
<https://bugs.launchpad.net/qemu/+bug/726619>
<https://forge.univention.org/bugzilla/show_bug.cgi?id=22221>

Sincerely
Philipp Hahn
-- 
Philipp Hahn           Open Source Software Engineer      hahn@univention.de
Univention GmbH        Linux for Your Business        fon: +49 421 22 232- 0
Mary-Somerville-Str.1  D-28359 Bremen                 fax: +49 421 22 232-99
                                                   http://www.univention.de/

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 197 bytes --]

Re: [Qemu-devel] [BUG] Re: [2/6] loadvm: improve tests before bdrv_snapshot_goto()

[Kevin Wolf]

Am 14.04.2011 11:10, schrieb Philipp Hahn:
> Hello,
> 
> Am Dienstag 03 August 2010 06:44:26 schrieb Kevin Wolf:
>> From: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
>>
>> This patch improves the resilience of the load_vmstate() function, doing
>> further and better ordered tests.
> 
> This patch broke restoring not-running VMs using libvirt-0.8.7 with qemu-0.14: 
> When the domain is not running while taking a snpshot, the sn.vm_state_size 
> == 0:
> 
> [...]
> 
> Previously the qcow2 image was still reverted to the old state, so on the next 
> start of the domain the qcow2 image would be in the state of the snapshot
> 
> [...]
> 
> Now the qcow2 image is not reverted and when the domain is started, it is NOT 
> in the state of the snapshot.
> 
> I can't decide if this regression is an Qemu bug or libvirt should be adapted 
> to this new behavior.

Ouch. I wouldn't have expected that libvirt relies on this qemu bug.
When libvirt doesn't use the VM state but boots a fresh VM, it should
call qemu-img snapshot -a for the disks rather than using the loadvm
monitor command.

Kevin

[Qemu-devel] [PULL 0/6] Block patches

[Kevin Wolf]

The following changes since commit 57aa265d462a64a06268be26d49020729cff56c1:

  lm32: add Milkymist Minimac2 support (2011-05-03 10:48:40 +0200)

are available in the git repository at:
  git://repo.or.cz/qemu/kevin.git for-anthony

Alon Levy (1):
      ide/atapi: fix set but unused

Amit Shah (2):
      atapi: Move comment to proper place
      atapi: Explain why we need a 'media not present' state

Jes Sorensen (1):
      qemu-progress.c: printf isn't signal safe

Kevin Wolf (1):
      qemu-img resize: Fix option parsing

Nick Thomas (1):
      NBD: Avoid leaking a couple of strings when the NBD device is closed

 block/nbd.c     |    4 ++++
 hw/ide/atapi.c  |   14 +++++++++-----
 qemu-img.c      |   13 +++++++++++--
 qemu-progress.c |    7 ++++++-
 4 files changed, 30 insertions(+), 8 deletions(-)

Re: [Qemu-devel] [PULL 0/6] Block patches

[Anthony Liguori]

On 05/03/2011 06:08 AM, Kevin Wolf wrote:
> The following changes since commit 57aa265d462a64a06268be26d49020729cff56c1:
>
>    lm32: add Milkymist Minimac2 support (2011-05-03 10:48:40 +0200)
>
> are available in the git repository at:
>    git://repo.or.cz/qemu/kevin.git for-anthony

Pulled.  Thanks.

Regards,

Anthony Liguori

> Alon Levy (1):
>        ide/atapi: fix set but unused
>
> Amit Shah (2):
>        atapi: Move comment to proper place
>        atapi: Explain why we need a 'media not present' state
>
> Jes Sorensen (1):
>        qemu-progress.c: printf isn't signal safe
>
> Kevin Wolf (1):
>        qemu-img resize: Fix option parsing
>
> Nick Thomas (1):
>        NBD: Avoid leaking a couple of strings when the NBD device is closed
>
>   block/nbd.c     |    4 ++++
>   hw/ide/atapi.c  |   14 +++++++++-----
>   qemu-img.c      |   13 +++++++++++--
>   qemu-progress.c |    7 ++++++-
>   4 files changed, 30 insertions(+), 8 deletions(-)

Re: [Qemu-devel] [libvirt] [BUG] Re: [2/6] loadvm: improve tests before bdrv_snapshot_goto()

[Eric Blake]

On 04/14/2011 03:29 AM, Kevin Wolf wrote:
> Am 14.04.2011 11:10, schrieb Philipp Hahn:

Reviving an old thread...

>> Hello,
>>
>> Am Dienstag 03 August 2010 06:44:26 schrieb Kevin Wolf:
>>> From: Miguel Di Ciurcio Filho<miguel.filho@gmail.com>
>>>
>>> This patch improves the resilience of the load_vmstate() function, doing
>>> further and better ordered tests.
>>
>> This patch broke restoring not-running VMs using libvirt-0.8.7 with qemu-0.14:
>> When the domain is not running while taking a snpshot, the sn.vm_state_size
>> == 0:
>>
>> [...]
>>
>> Previously the qcow2 image was still reverted to the old state, so on the next
>> start of the domain the qcow2 image would be in the state of the snapshot
>>
>> [...]
>>
>> Now the qcow2 image is not reverted and when the domain is started, it is NOT
>> in the state of the snapshot.
>>
>> I can't decide if this regression is an Qemu bug or libvirt should be adapted
>> to this new behavior.
>
> Ouch. I wouldn't have expected that libvirt relies on this qemu bug.
> When libvirt doesn't use the VM state but boots a fresh VM, it should
> call qemu-img snapshot -a for the disks rather than using the loadvm
> monitor command.

Libvirt should be using 'qemu-img snapshot -a' before reverting to a 
snapshot made via 'qemu-img snapshot -c'; I'm writing the patch now.

-- 
Eric Blake   eblake@redhat.com    +1-801-349-2682
Libvirt virtualization library http://libvirt.org

[Qemu-devel] [PULL 0/6] Block patches

[Kevin Wolf]

The following changes since commit 63fb2590839162afdf14d7c0ee02d460766c0956:

  Merge branch 'target-arm.next' of git://git.linaro.org/people/pmaydell/qemu-arm (2013-01-12 12:47:07 +0000)

are available in the git repository at:

  git://repo.or.cz/qemu/kevin.git for-anthony

Liu Yuan (1):
      sheepdog: implement direct write semantics

Paolo Bonzini (2):
      block: do not probe zero-sized disks
      raw-posix: fix bdrv_aio_ioctl

Stefan Hajnoczi (3):
      block: make qiov_is_aligned() public
      dataplane: extract virtio-blk read/write processing into do_rdwr_cmd()
      dataplane: handle misaligned virtio-blk requests

 block.c                   |   18 +++++++++++-
 block/raw-posix.c         |   28 +----------------
 block/sheepdog.c          |   70 +++++++++++++++++++++++++-------------------
 hw/dataplane/virtio-blk.c |   71 ++++++++++++++++++++++++++++++++++++++-------
 include/block/block.h     |    1 +
 5 files changed, 120 insertions(+), 68 deletions(-)

Re: [Qemu-devel] [PULL 0/6] Block patches

[Anthony Liguori]

Pulled.  Thanks.

Regards,

Anthony Liguori

[Qemu-devel] [PULL 0/6] Block patches

[Kevin Wolf]

The following changes since commit 47acdd63a33a5966bf4fc94a6ac835d72a70c555:

  target-microblaze: Use the new qemu_ld/st opcodes (2013-12-13 10:00:42 +1000)

are available in the git repository at:

  git://repo.or.cz/qemu/kevin.git tags/for-anthony

for you to fetch changes up to c547e5640d5b0993cdfb252331065c1a1d813bd8:

  blkdebug: Use QLIST_FOREACH_SAFE to resume IO (2013-12-13 17:11:19 +0100)

----------------------------------------------------------------
Block patches

----------------------------------------------------------------
Fam Zheng (1):
      blkdebug: Use QLIST_FOREACH_SAFE to resume IO

Kevin Wolf (1):
      qapi-schema.json: Change 1.8 reference to 2.0

Liu Yuan (1):
      sheepdog: check if '-o redundancy' is passed from user

Peter Lieven (2):
      block: expect get_block_status errors in bdrv_make_zero
      qemu-img: make progress output more accurate during convert

Stefan Weil (1):
      block/vvfat: Fix compiler warnings for OpenBSD

 block.c          |  5 +++++
 block/blkdebug.c |  8 ++++----
 block/sheepdog.c |  8 +++++---
 block/vvfat.c    | 43 ++++++++++++++++++++++---------------------
 qapi-schema.json |  2 +-
 qemu-img.c       | 26 +++++++++++++++++++++-----
 6 files changed, 58 insertions(+), 34 deletions(-)

[Qemu-devel] [PULL 0/6] Block patches

[Stefan Hajnoczi]

The following changes since commit 427e1750a0b98a72cad424327604f51e993dcc5f:

  gt64xxx_pci: Add VMStateDescription (2014-06-20 23:40:16 +0200)

are available in the git repository at:

  git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 2bd3bce8efebe86b031beab5c0e3b9bbaec0b502:

  block: asynchronously stop the VM on I/O errors (2014-06-23 16:36:13 +0800)

----------------------------------------------------------------
Block pull request

----------------------------------------------------------------
Chunyan Liu (1):
      QemuOpts: check NULL opts in qemu_opt_get functions

Liu Yuan (1):
      sheepdog: fix NULL dereference in sd_create

Paolo Bonzini (2):
      vl: allow other threads to do qemu_system_vmstop_request
      block: asynchronously stop the VM on I/O errors

Peter Crosthwaite (2):
      block: m25p80: sync_page(): Deindent function body.
      block: m25p80: Support read only bdrvs.

 block.c                 | 21 ++++++++++--
 block/sheepdog.c        |  1 +
 cpus.c                  |  1 +
 docs/qmp/qmp-events.txt |  2 +-
 hw/block/m25p80.c       | 30 ++++++++---------
 include/sysemu/sysemu.h |  1 +
 stubs/vm-stop.c         |  7 +++-
 target-lm32/op_helper.c |  2 +-
 util/qemu-option.c      | 28 +++++++++++++---
 vl.c                    | 85 +++++++++++++++++++++++++++++++------------------
 10 files changed, 122 insertions(+), 56 deletions(-)

-- 
1.9.3

Re: [Qemu-devel] [PULL 0/6] Block patches

[Peter Maydell]

On 23 June 2014 10:31, Stefan Hajnoczi <stefanha@redhat.com> wrote:
> The following changes since commit 427e1750a0b98a72cad424327604f51e993dcc5f:
>
>   gt64xxx_pci: Add VMStateDescription (2014-06-20 23:40:16 +0200)
>
> are available in the git repository at:
>
>   git://github.com/stefanha/qemu.git tags/block-pull-request
>
> for you to fetch changes up to 2bd3bce8efebe86b031beab5c0e3b9bbaec0b502:
>
>   block: asynchronously stop the VM on I/O errors (2014-06-23 16:36:13 +0800)
>
> ----------------------------------------------------------------
> Block pull request

Applied, thanks.

-- PMM

[Qemu-devel] [PULL 0/6] Block patches

[Stefan Hajnoczi]

The following changes since commit 136c67e07869227b21b3f627316e03679ce7b738:

  Merge remote-tracking branch 'remotes/bkoppelmann/tags/pull-tricore-2018-03-02' into staging (2018-03-02 16:56:20 +0000)

are available in the Git repository at:

  git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 23500c6a9409efc80d696aede0629bfbe7556a90:

  README: Document 'git-publish' workflow (2018-03-05 09:03:17 +0000)

----------------------------------------------------------------
Pull request

Mostly patches that are only indirectly related to the block layer, but I've
reviewed them and there is no maintainer.

----------------------------------------------------------------

Fam Zheng (2):
  Add a git-publish configuration file
  README: Document 'git-publish' workflow

Su Hang (3):
  util/uri.c: Coding style check, Only whitespace involved
  util/uri.c: remove brackets that wrap `return` statement's content.
  util/uri.c: wrap single statement blocks with braces {}

Thomas Huth (1):
  tests/libqos: Check for valid dev pointer when looking for PCI devices

 tests/libqos/virtio-pci.c |    4 +-
 util/uri.c                | 1733 ++++++++++++++++++++++++---------------------
 .gitpublish               |   51 ++
 README                    |   31 +-
 4 files changed, 1014 insertions(+), 805 deletions(-)
 create mode 100644 .gitpublish

-- 
2.14.3

Re: [Qemu-devel] [PULL 0/6] Block patches

[no-reply]

Hi,

This series seems to have some coding style problems. See output below for
more information:

Type: series
Message-id: 20180305094006.21446-1-stefanha@redhat.com
Subject: [Qemu-devel] [PULL 0/6] Block patches

=== TEST SCRIPT BEGIN ===
#!/bin/bash

BASE=base
n=1
total=$(git log --oneline $BASE.. | wc -l)
failed=0

git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram

commits="$(git log --format=%H --reverse $BASE..)"
for c in $commits; do
    echo "Checking PATCH $n/$total: $(git log -n 1 --format=%s $c)..."
    if ! git show $c --format=email | ./scripts/checkpatch.pl --mailback -; then
        failed=1
        echo
    fi
    n=$((n+1))
done

exit $failed
=== TEST SCRIPT END ===

Updating 3c8cf5a9c21ff8782164d1def7f44bd888713384
From https://github.com/patchew-project/qemu
   136c67e078..4f51e1d386  master     -> master
 * [new tag]               patchew/1520243276-30197-1-git-send-email-thuth@redhat.com -> patchew/1520243276-30197-1-git-send-email-thuth@redhat.com
 * [new tag]               patchew/20180305094006.21446-1-stefanha@redhat.com -> patchew/20180305094006.21446-1-stefanha@redhat.com
Switched to a new branch 'test'
20eeab9795 README: Document 'git-publish' workflow
333283c56b Add a git-publish configuration file
3a9752c776 tests/libqos: Check for valid dev pointer when looking for PCI devices
6863406cb9 util/uri.c: wrap single statement blocks with braces {}
906ebc14e5 util/uri.c: remove brackets that wrap `return` statement's content.
d0e12d0916 util/uri.c: Coding style check, Only whitespace involved

=== OUTPUT BEGIN ===
Checking PATCH 1/6: util/uri.c: Coding style check, Only whitespace involved...
ERROR: return is not a function, parentheses are not required
#171: FILE: util/uri.c:215:
+        return (-1);

ERROR: return is not a function, parentheses are not required
#176: FILE: util/uri.c:219:
+        return (2);

ERROR: return is not a function, parentheses are not required
#190: FILE: util/uri.c:229:
+    return (0);

ERROR: braces {} are necessary for all arms of this statement
#212: FILE: util/uri.c:262:
+        if (uri->cleanup & 2)
[...]
+        else
[...]

ERROR: braces {} are necessary for all arms of this statement
#276: FILE: util/uri.c:359:
+            if (uri->cleanup & 2)
[...]
+            else
[...]

ERROR: return is not a function, parentheses are not required
#282: FILE: util/uri.c:365:
+        return (0);

ERROR: return is not a function, parentheses are not required
#285: FILE: util/uri.c:367:
+    return (1);

ERROR: return is not a function, parentheses are not required
#305: FILE: util/uri.c:389:
+        return (1);

ERROR: braces {} are necessary for all arms of this statement
#306: FILE: util/uri.c:390:
+    if (!ISA_DIGIT(cur + 1))
[...]
+    else if ((*cur != '0') && (ISA_DIGIT(cur + 1)) && (!ISA_DIGIT(cur + 2)))
[...]
     else if ((*cur == '1') && (ISA_DIGIT(cur + 1)) && (ISA_DIGIT(cur + 2)))
[...]
-    else if ((*cur == '2') && (*(cur + 1) >= '0') &&
[...]
-    else if ((*cur == '2') && (*(cur + 1) == '5') &&
[...]
+        cur += 3;
[...]

ERROR: braces {} are necessary for all arms of this statement
#308: FILE: util/uri.c:392:
+    else if ((*cur != '0') && (ISA_DIGIT(cur + 1)) && (!ISA_DIGIT(cur + 2)))
[...]
     else if ((*cur == '1') && (ISA_DIGIT(cur + 1)) && (ISA_DIGIT(cur + 2)))
[...]
-    else if ((*cur == '2') && (*(cur + 1) >= '0') &&
[...]
-    else if ((*cur == '2') && (*(cur + 1) == '5') &&
[...]
+        cur += 3;
[...]

ERROR: braces {} are necessary for all arms of this statement
#319: FILE: util/uri.c:396:
+    else if ((*cur == '2') && (*(cur + 1) >= '0') && (*(cur + 1) <= '4') &&
[...]
+    else if ((*cur == '2') && (*(cur + 1) == '5') && (*(cur + 2) >= '0') &&
[...]
     else
[...]

ERROR: braces {} are necessary for all arms of this statement
#322: FILE: util/uri.c:399:
+    else if ((*cur == '2') && (*(cur + 1) == '5') && (*(cur + 2) >= '0') &&
[...]
     else
[...]

ERROR: return is not a function, parentheses are not required
#327: FILE: util/uri.c:403:
+        return (1);

ERROR: return is not a function, parentheses are not required
#330: FILE: util/uri.c:405:
+    return (0);

ERROR: braces {} are necessary even for single statement blocks
#354: FILE: util/uri.c:433:
+        while ((*cur != ']') && (*cur != 0))
+            cur++;

ERROR: braces {} are necessary for all arms of this statement
#356: FILE: util/uri.c:435:
+        if (*cur != ']')
[...]

ERROR: return is not a function, parentheses are not required
#357: FILE: util/uri.c:436:
+            return (1);

ERROR: braces {} are necessary for all arms of this statement
#371: FILE: util/uri.c:446:
+        if (*cur != '.')
[...]

ERROR: braces {} are necessary for all arms of this statement
#379: FILE: util/uri.c:451:
+        if (*cur != '.')
[...]

ERROR: braces {} are necessary for all arms of this statement
#386: FILE: util/uri.c:455:
+        if (*cur != '.')
[...]

ERROR: braces {} are necessary for all arms of this statement
#412: FILE: util/uri.c:473:
+        if (cur != host) {
[...]
+        } else
[...]

ERROR: braces {} are necessary for all arms of this statement
#413: FILE: util/uri.c:474:
+            if (uri->cleanup & 2)
[...]
+            else
[...]

ERROR: return is not a function, parentheses are not required
#422: FILE: util/uri.c:482:
+    return (0);

ERROR: braces {} are necessary for all arms of this statement
#441: FILE: util/uri.c:512:
+    if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#442: FILE: util/uri.c:513:
+        return (ret);

ERROR: braces {} are necessary for all arms of this statement
#447: FILE: util/uri.c:517:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#448: FILE: util/uri.c:518:
+            return (ret);

ERROR: return is not a function, parentheses are not required
#452: FILE: util/uri.c:521:
+    return (0);

ERROR: return is not a function, parentheses are not required
#471: FILE: util/uri.c:547:
+            return (0);

ERROR: return is not a function, parentheses are not required
#472: FILE: util/uri.c:548:
+        return (1);

ERROR: return is not a function, parentheses are not required
#494: FILE: util/uri.c:579:
+            return (ret);

ERROR: return is not a function, parentheses are not required
#513: FILE: util/uri.c:616:
+        return (1);

ERROR: return is not a function, parentheses are not required
#526: FILE: util/uri.c:624:
+                return (ret);

ERROR: braces {} are necessary for all arms of this statement
#546: FILE: util/uri.c:662:
+    if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#547: FILE: util/uri.c:663:
+        return (ret);

ERROR: return is not a function, parentheses are not required
#554: FILE: util/uri.c:668:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#573: FILE: util/uri.c:705:
+    if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#574: FILE: util/uri.c:706:
+        return (ret);

ERROR: return is not a function, parentheses are not required
#581: FILE: util/uri.c:711:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#606: FILE: util/uri.c:753:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#607: FILE: util/uri.c:754:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#609: FILE: util/uri.c:756:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#610: FILE: util/uri.c:757:
+            return (ret);

ERROR: return is not a function, parentheses are not required
#612: FILE: util/uri.c:759:
+        return (0);

ERROR: braces {} are necessary for all arms of this statement
#616: FILE: util/uri.c:762:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#617: FILE: util/uri.c:763:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#621: FILE: util/uri.c:766:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#622: FILE: util/uri.c:767:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#653: FILE: util/uri.c:802:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#654: FILE: util/uri.c:803:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#656: FILE: util/uri.c:805:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#657: FILE: util/uri.c:806:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#662: FILE: util/uri.c:809:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#663: FILE: util/uri.c:810:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#667: FILE: util/uri.c:813:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#668: FILE: util/uri.c:814:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#687: FILE: util/uri.c:826:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#688: FILE: util/uri.c:827:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#696: FILE: util/uri.c:832:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#697: FILE: util/uri.c:833:
+            return (ret);

ERROR: return is not a function, parentheses are not required
#703: FILE: util/uri.c:837:
+        return (1);

ERROR: return is not a function, parentheses are not required
#706: FILE: util/uri.c:839:
+    return (0);

ERROR: braces {} are necessary for all arms of this statement
#725: FILE: util/uri.c:859:
+    if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#726: FILE: util/uri.c:860:
+        return (ret);

ERROR: return is not a function, parentheses are not required
#729: FILE: util/uri.c:862:
+        return (1);

ERROR: braces {} are necessary for all arms of this statement
#734: FILE: util/uri.c:866:
+    if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#735: FILE: util/uri.c:867:
+        return (ret);

ERROR: braces {} are necessary for all arms of this statement
#742: FILE: util/uri.c:871:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#743: FILE: util/uri.c:872:
+            return (ret);

ERROR: braces {} are necessary for all arms of this statement
#751: FILE: util/uri.c:877:
+        if (ret != 0)
[...]

ERROR: return is not a function, parentheses are not required
#752: FILE: util/uri.c:878:
+            return (ret);

ERROR: return is not a function, parentheses are not required
#758: FILE: util/uri.c:882:
+        return (1);

ERROR: return is not a function, parentheses are not required
#761: FILE: util/uri.c:884:
+    return (0);

ERROR: return is not a function, parentheses are not required
#777: FILE: util/uri.c:904:
+        return (-1);

ERROR: return is not a function, parentheses are not required
#794: FILE: util/uri.c:917:
+            return (ret);

ERROR: return is not a function, parentheses are not required
#798: FILE: util/uri.c:920:
+    return (0);

ERROR: return is not a function, parentheses are not required
#815: FILE: util/uri.c:939:
+        return (NULL);

ERROR: return is not a function, parentheses are not required
#821: FILE: util/uri.c:944:
+        return (NULL);

ERROR: return is not a function, parentheses are not required
#824: FILE: util/uri.c:946:
+    return (uri);

ERROR: return is not a function, parentheses are not required
#837: FILE: util/uri.c:963:
+    return (rfc3986_parse_uri_reference(uri, str));

ERROR: return is not a function, parentheses are not required
#854: FILE: util/uri.c:983:
+        return (NULL);

ERROR: return is not a function, parentheses are not required
#863: FILE: util/uri.c:991:
+        return (NULL);

ERROR: return is not a function, parentheses are not required
#866: FILE: util/uri.c:993:
+    return (uri);

ERROR: return is not a function, parentheses are not required
#891: FILE: util/uri.c:1014:
+    return (ret);

ERROR: return is not a function, parentheses are not required
#910: FILE: util/uri.c:1031:
+    return (temp);

ERROR: braces {} are necessary for all arms of this statement
#930: FILE: util/uri.c:1050:
+    if (uri == NULL)
[...]

ERROR: return is not a function, parentheses are not required
#931: FILE: util/uri.c:1051:
+        return (NULL);

ERROR: braces {} are necessary for all arms of this statement
#983: FILE: util/uri.c:1079:
+            if (IS_RESERVED(*(p)) || IS_UNRESERVED(*(p)))
[...]
+            else {
[...]

ERROR: braces {} are necessary for all arms of this statement
#1033: FILE: util/uri.c:1104:
+                    if ((IS_UNRESERVED(*(p))) || ((*(p) == ';')) ||
[...]
+                    else {
[...]

ERROR: braces {} are necessary for all arms of this statement
#1117: FILE: util/uri.c:1150:
+                if ((IS_UNRESERVED(*(p))) || ((*(p) == '$')) ||
[...]
+                else {
[...]

ERROR: braces {} are necessary for all arms of this statement
#1187: FILE: util/uri.c:1194:
+                if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
[...]
-		else {
[...]

ERROR: braces {} are necessary for all arms of this statement
#1269: FILE: util/uri.c:1236:
+            if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
[...]
+            else {
[...]

ERROR: return is not a function, parentheses are not required
#1286: FILE: util/uri.c:1252:
+    return (ret);

ERROR: braces {} are necessary for all arms of this statement
#1299: FILE: util/uri.c:1263:
+    if (uri == NULL)
[...]

ERROR: return is not a function, parentheses are not required
#1338: FILE: util/uri.c:1318:
+        return (-1);

ERROR: return is not a function, parentheses are not required
#1349: FILE: util/uri.c:1327:
+        return (0);

ERROR: braces {} are necessary even for single statement blocks
#1375: FILE: util/uri.c:1343:
+            while (cur[0] == '/')
+                cur++;

ERROR: braces {} are necessary for all arms of this statement
#1390: FILE: util/uri.c:1352:
+        if ((cur[0] == '.') && (cur[1] == '\0'))
[...]

ERROR: braces {} are necessary even for single statement blocks
#1408: FILE: util/uri.c:1362:
+        while ((cur[0] == '/') && (cur[1] == '/'))
+            cur++;

ERROR: return is not a function, parentheses are not required
#1424: FILE: util/uri.c:1375:
+        return (0);

ERROR: braces {} are necessary even for single statement blocks
#1517: FILE: util/uri.c:1482:
+            while (cur[0] != '\0')
+                (out++)[0] = (cur++)[0];

ERROR: return is not a function, parentheses are not required
#1524: FILE: util/uri.c:1488:
+    return (0);

ERROR: braces {} are necessary for all arms of this statement
#1532: FILE: util/uri.c:1493:
+    if (((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) ||
[...]

ERROR: return is not a function, parentheses are not required
#1536: FILE: util/uri.c:1495:
+        return (1);

ERROR: return is not a function, parentheses are not required
#1537: FILE: util/uri.c:1496:
+    return (0);

ERROR: return is not a function, parentheses are not required
#1559: FILE: util/uri.c:1519:
+        return (NULL);

ERROR: braces {} are necessary for all arms of this statement
#1560: FILE: util/uri.c:1520:
+    if (len <= 0)
[...]

ERROR: braces {} are necessary for all arms of this statement
#1562: FILE: util/uri.c:1522:
+    if (len < 0)
[...]

ERROR: return is not a function, parentheses are not required
#1563: FILE: util/uri.c:1523:
+        return (NULL);

ERROR: braces {} are necessary for all arms of this statement
#1599: FILE: util/uri.c:1534:
+            if ((*in >= '0') && (*in <= '9'))
[...]
+            else if ((*in >= 'a') && (*in <= 'f'))
[...]
+            else if ((*in >= 'A') && (*in <= 'F'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#1601: FILE: util/uri.c:1536:
+            else if ((*in >= 'a') && (*in <= 'f'))
[...]
+            else if ((*in >= 'A') && (*in <= 'F'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#1603: FILE: util/uri.c:1538:
+            else if ((*in >= 'A') && (*in <= 'F'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#1606: FILE: util/uri.c:1541:
+            if ((*in >= '0') && (*in <= '9'))
[...]
+            else if ((*in >= 'a') && (*in <= 'f'))
[...]
+            else if ((*in >= 'A') && (*in <= 'F'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#1608: FILE: util/uri.c:1543:
+            else if ((*in >= 'a') && (*in <= 'f'))
[...]
+            else if ((*in >= 'A') && (*in <= 'F'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#1610: FILE: util/uri.c:1545:
+            else if ((*in >= 'A') && (*in <= 'F'))
[...]

ERROR: return is not a function, parentheses are not required
#1622: FILE: util/uri.c:1556:
+    return (ret);

ERROR: return is not a function, parentheses are not required
#1641: FILE: util/uri.c:1577:
+        return (NULL);

ERROR: return is not a function, parentheses are not required
#1644: FILE: util/uri.c:1579:
+        return (g_strdup(str));

ERROR: braces {} are necessary for all arms of this statement
#1647: FILE: util/uri.c:1581:
+    if (!(len > 0))
[...]

ERROR: return is not a function, parentheses are not required
#1648: FILE: util/uri.c:1582:
+        return (NULL);

ERROR: braces {} are necessary for all arms of this statement
#1689: FILE: util/uri.c:1600:
+            if (val <= 9)
[...]
+            else
[...]

ERROR: braces {} are necessary for all arms of this statement
#1694: FILE: util/uri.c:1605:
+            if (val <= 9)
[...]
+            else
[...]

ERROR: return is not a function, parentheses are not required
#1705: FILE: util/uri.c:1615:
+    return (ret);

ERROR: braces {} are necessary for all arms of this statement
#1742: FILE: util/uri.c:1658:
+        if (*uri) {
[...]
+        } else
[...]

ERROR: braces {} are necessary for all arms of this statement
#1776: FILE: util/uri.c:1680:
+        if (ref)
[...]

ERROR: braces {} are necessary for all arms of this statement
#1806: FILE: util/uri.c:1710:
+        if (bas->authority != NULL)
[...]
+        else if (bas->server != NULL) {
[...]

ERROR: braces {} are necessary for all arms of this statement
#1846: FILE: util/uri.c:1750:
+        if (ref->authority != NULL)
[...]
+        else {
[...]

ERROR: braces {} are necessary even for single statement blocks
#1905: FILE: util/uri.c:1802:
+            while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
+                cur++;

ERROR: braces {} are necessary for all arms of this statement
#1907: FILE: util/uri.c:1804:
+            if (bas->path[cur] == 0)
[...]

ERROR: braces {} are necessary for all arms of this statement
#1942: FILE: util/uri.c:1825:
+        if ((out == 0) && (bas->server != NULL))
[...]

ERROR: return is not a function, parentheses are not required
#1963: FILE: util/uri.c:1854:
+    return (val);

ERROR: braces {} are necessary for all arms of this statement
#1995: FILE: util/uri.c:1912:
+        if (ret != 0)
[...]

ERROR: braces {} are necessary for all arms of this statement
#2017: FILE: util/uri.c:1927:
+        if (ret != 0)
[...]

ERROR: braces {} are necessary for all arms of this statement
#2073: FILE: util/uri.c:1965:
+            if (*uptr == '/')
[...]

ERROR: braces {} are necessary for all arms of this statement
#2089: FILE: util/uri.c:1975:
+            if (bptr[ix] == '/')
[...]

ERROR: braces {} are necessary for all arms of this statement
#2102: FILE: util/uri.c:1984:
+        if ((ref->path[pos] == '.') && (ref->path[pos + 1] == '/'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#2105: FILE: util/uri.c:1986:
+        if ((*bptr == '.') && (bptr[1] == '/'))
[...]
-	else if ((*bptr == '/') && (ref->path[pos] != '/'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#2111: FILE: util/uri.c:1988:
+        else if ((*bptr == '/') && (ref->path[pos] != '/'))
[...]

ERROR: braces {} are necessary even for single statement blocks
#2113: FILE: util/uri.c:1990:
+        while ((bptr[pos] == ref->path[pos]) && (bptr[pos] != 0))
+            pos++;

ERROR: braces {} are necessary for all arms of this statement
#2149: FILE: util/uri.c:2003:
+        if ((ref->path[ix] == '/') && (ix > 0))
[...]
+        else if ((ref->path[ix] == 0) && (ix > 1) && (ref->path[ix - 1] == '/'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#2151: FILE: util/uri.c:2005:
+        else if ((ref->path[ix] == 0) && (ix > 1) && (ref->path[ix - 1] == '/'))
[...]

ERROR: braces {} are necessary for all arms of this statement
#2154: FILE: util/uri.c:2008:
+            if (ref->path[ix] == '/')
[...]

ERROR: braces {} are necessary for all arms of this statement
#2179: FILE: util/uri.c:2023:
+                if (bptr[ix] == '/')
[...]

ERROR: braces {} are necessary for all arms of this statement
#2191: FILE: util/uri.c:2031:
+        if (uptr != NULL)
[...]

ERROR: braces {} are necessary for all arms of this statement
#2272: FILE: util/uri.c:2096:
+    if (init_alloc <= 0)
[...]

ERROR: braces {} are necessary for all arms of this statement
#2341: FILE: util/uri.c:2159:
+        if (eq && eq >= end)
[...]

ERROR: braces {} are necessary for all arms of this statement
#2383: FILE: util/uri.c:2199:
+        if (*query)
[...]

total: 147 errors, 0 warnings, 2299 lines checked

Your patch has style problems, please review.  If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.

Checking PATCH 2/6: util/uri.c: remove brackets that wrap `return` statement's content....
Checking PATCH 3/6: util/uri.c: wrap single statement blocks with braces {}...
Checking PATCH 4/6: tests/libqos: Check for valid dev pointer when looking for PCI devices...
Checking PATCH 5/6: Add a git-publish configuration file...
Checking PATCH 6/6: README: Document 'git-publish' workflow...
=== OUTPUT END ===

Test command exited with code: 1


---
Email generated automatically by Patchew [http://patchew.org/].
Please send your feedback to patchew-devel@freelists.org

Re: [Qemu-devel] [PULL 0/6] Block patches

[Peter Maydell]

On 5 March 2018 at 09:40, Stefan Hajnoczi <stefanha@redhat.com> wrote:
> The following changes since commit 136c67e07869227b21b3f627316e03679ce7b738:
>
>   Merge remote-tracking branch 'remotes/bkoppelmann/tags/pull-tricore-2018-03-02' into staging (2018-03-02 16:56:20 +0000)
>
> are available in the Git repository at:
>
>   git://github.com/stefanha/qemu.git tags/block-pull-request
>
> for you to fetch changes up to 23500c6a9409efc80d696aede0629bfbe7556a90:
>
>   README: Document 'git-publish' workflow (2018-03-05 09:03:17 +0000)
>
> ----------------------------------------------------------------
> Pull request
>
> Mostly patches that are only indirectly related to the block layer, but I've
> reviewed them and there is no maintainer.
>
> ----------------------------------------------------------------
>
> Fam Zheng (2):
>   Add a git-publish configuration file
>   README: Document 'git-publish' workflow
>
> Su Hang (3):
>   util/uri.c: Coding style check, Only whitespace involved
>   util/uri.c: remove brackets that wrap `return` statement's content.
>   util/uri.c: wrap single statement blocks with braces {}
>
> Thomas Huth (1):
>   tests/libqos: Check for valid dev pointer when looking for PCI devices
>
>  tests/libqos/virtio-pci.c |    4 +-
>  util/uri.c                | 1733 ++++++++++++++++++++++++---------------------
>  .gitpublish               |   51 ++
>  README                    |   31 +-
>  4 files changed, 1014 insertions(+), 805 deletions(-)
>  create mode 100644 .gitpublish

Applied, thanks.

-- PMM