qemu-trivial
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Qemu-trivial] [PATCH v3] block: replace fprintf(stderr, ...) with error


From: Le Tan
Subject: [Qemu-trivial] [PATCH v3] block: replace fprintf(stderr, ...) with error_report()
Date: Sun, 25 May 2014 10:44:13 +0800

Replace fprintf(stderr,...) with error_report() in files block/*, block.c,
block-migration.c and blockdev.c. The trailing "\n"s of the @fmt argument
have been removed because @fmt of error_report() should not contain newline.
Also fix some coding style issues.

Signed-off-by: Le Tan <address@hidden>
---
 block-migration.c      |    7 +-
 block.c                |   58 +++++-----
 block/qcow2-refcount.c |  274 ++++++++++++++++++++++++------------------------
 block/qcow2.c          |   54 +++++-----
 block/raw-posix.c      |  122 ++++++++++-----------
 block/raw-win32.c      |   59 ++++++-----
 block/ssh.c            |   26 ++---
 block/vdi.c            |   19 ++--
 block/vmdk.c           |   62 ++++++-----
 block/vpc.c            |   22 ++--
 block/vvfat.c          |  143 ++++++++++++-------------
 blockdev.c             |   27 +++--
 12 files changed, 441 insertions(+), 432 deletions(-)

diff --git a/block-migration.c b/block-migration.c
index 56951e0..004f548 100644
--- a/block-migration.c
+++ b/block-migration.c
@@ -33,7 +33,7 @@
 
 #define MAX_IS_ALLOCATED_SEARCH 65536
 
-//#define DEBUG_BLK_MIGRATION
+/* #define DEBUG_BLK_MIGRATION */
 
 #ifdef DEBUG_BLK_MIGRATION
 #define DPRINTF(fmt, ...) \
@@ -790,8 +790,7 @@ static int block_load(QEMUFile *f, void *opaque, int 
version_id)
 
             bs = bdrv_find(device_name);
             if (!bs) {
-                fprintf(stderr, "Error unknown block device %s\n",
-                        device_name);
+                error_report("Error unknown block device %s", device_name);
                 return -EINVAL;
             }
 
@@ -833,7 +832,7 @@ static int block_load(QEMUFile *f, void *opaque, int 
version_id)
                    (addr == 100) ? '\n' : '\r');
             fflush(stdout);
         } else if (!(flags & BLK_MIG_FLAG_EOS)) {
-            fprintf(stderr, "Unknown block migration flags: %#x\n", flags);
+            error_report("Unknown block migration flags: %#x", flags);
             return -EINVAL;
         }
         ret = qemu_file_get_error(f);
diff --git a/block.c b/block.c
index c90c71a..e7f620d 100644
--- a/block.c
+++ b/block.c
@@ -453,7 +453,8 @@ int bdrv_create(BlockDriver *drv, const char* filename,
     };
 
     if (!drv->bdrv_create) {
-        error_setg(errp, "Driver '%s' does not support image creation", 
drv->format_name);
+        error_setg(errp, "Driver '%s' does not support image creation",
+                   drv->format_name);
         ret = -ENOTSUP;
         goto out;
     }
@@ -483,7 +484,7 @@ out:
     return ret;
 }
 
-int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
+int bdrv_create_file(const char *filename, QEMUOptionParameter *options,
                      Error **errp)
 {
     BlockDriver *drv;
@@ -2186,7 +2187,7 @@ int bdrv_commit(BlockDriverState *bs)
 
     if (!drv)
         return -ENOMEDIUM;
-    
+
     if (!bs->backing_hd) {
         return -ENOTSUP;
     }
@@ -2412,8 +2413,7 @@ static bool coroutine_fn 
wait_serialising_requests(BdrvTrackedRequest *self)
                 continue;
             }
             if (tracked_request_overlaps(req, self->overlap_offset,
-                                         self->overlap_bytes))
-            {
+                                         self->overlap_bytes)) {
                 /* Hitting this means there was a reentrant request, for
                  * example, a block driver issuing nested requests.  This must
                  * never happen since it means deadlock.
@@ -2465,7 +2465,8 @@ int bdrv_change_backing_file(BlockDriverState *bs,
 
     if (ret == 0) {
         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: 
"");
-        pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: 
"");
+        pstrcpy(bs->backing_format, sizeof(bs->backing_format),
+                backing_fmt ?: "");
     }
     return ret;
 }
@@ -2698,8 +2699,8 @@ static int bdrv_prwv_co(BlockDriverState *bs, int64_t 
offset,
      * if it has been enabled.
      */
     if (bs->io_limits_enabled) {
-        fprintf(stderr, "Disabling I/O throttling on '%s' due "
-                        "to synchronous I/O.\n", bdrv_get_device_name(bs));
+        error_report("Disabling I/O throttling on '%s' due "
+                     "to synchronous I/O.", bdrv_get_device_name(bs));
         bdrv_io_limits_disable(bs);
     }
 
@@ -3362,8 +3363,8 @@ static int coroutine_fn 
bdrv_co_do_pwritev(BlockDriverState *bs,
         qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
 
         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
-        ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), 
align,
-                                  align, &tail_qiov, 0);
+        ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1),
+                                  align, align, &tail_qiov, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -3515,7 +3516,8 @@ BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, 
bool is_read)
     return is_read ? bs->on_read_error : bs->on_write_error;
 }
 
-BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int 
error)
+BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read,
+                                       int error)
 {
     BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
 
@@ -4372,17 +4374,18 @@ static int multiwrite_merge(BlockDriverState *bs, 
BlockRequest *reqs,
 {
     int i, outidx;
 
-    // Sort requests by start sector
+    /* Sort requests by start sector */
     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
 
-    // Check if adjacent requests touch the same clusters. If so, combine them,
-    // filling up gaps with zero sectors.
+    /* Check if adjacent requests touch the same clusters. If so, combine them,
+     * filling up gaps with zero sectors.
+     */
     outidx = 0;
     for (i = 1; i < num_reqs; i++) {
         int merge = 0;
         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
 
-        // Handle exactly sequential writes and overlapping writes.
+        /* Handle exactly sequential writes and overlapping writes. */
         if (reqs[i].sector <= oldreq_last) {
             merge = 1;
         }
@@ -4397,15 +4400,16 @@ static int multiwrite_merge(BlockDriverState *bs, 
BlockRequest *reqs,
             qemu_iovec_init(qiov,
                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
 
-            // Add the first request to the merged one. If the requests are
-            // overlapping, drop the last sectors of the first request.
+            /* Add the first request to the merged one. If the requests are
+             * overlapping, drop the last sectors of the first request.
+             */
             size = (reqs[i].sector - reqs[outidx].sector) << 9;
             qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
 
-            // We should need to add any zeros between the two requests
-            assert (reqs[i].sector <= oldreq_last);
+            /* We should need to add any zeros between the two requests */
+            assert(reqs[i].sector <= oldreq_last);
 
-            // Add the second request
+            /* Add the second request */
             qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
 
             reqs[outidx].nb_sectors = qiov->size >> 9;
@@ -4454,7 +4458,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, 
BlockRequest *reqs, int num_reqs)
         return 0;
     }
 
-    // Create MultiwriteCB structure
+    /* Create MultiwriteCB structure */
     mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
     mcb->num_requests = 0;
     mcb->num_callbacks = num_reqs;
@@ -4464,7 +4468,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, 
BlockRequest *reqs, int num_reqs)
         mcb->callbacks[i].opaque = reqs[i].opaque;
     }
 
-    // Check for mergable requests
+    /* Check for mergable requests */
     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
 
     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
@@ -4575,7 +4579,7 @@ typedef struct BlockDriverAIOCBCoroutine {
     BlockRequest req;
     bool is_write;
     bool *done;
-    QEMUBH* bh;
+    QEMUBH *bh;
 } BlockDriverAIOCBCoroutine;
 
 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
@@ -5219,7 +5223,8 @@ BlockDirtyInfoList 
*bdrv_query_dirty_bitmaps(BlockDriverState *bs)
     return list;
 }
 
-int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t 
sector)
+int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
+                   int64_t sector)
 {
     if (bitmap) {
         return hbitmap_get(bitmap->bitmap, sector);
@@ -5425,8 +5430,9 @@ void bdrv_img_create(const char *filename, const char 
*fmt,
         }
     }
 
-    // The size for the image must always be specified, with one exception:
-    // If we are using a backing file, we can obtain the size from there
+    /* The size for the image must always be specified, with one exception:
+     * If we are using a backing file, we can obtain the size from there
+     */
     size = get_option_parameter(param, BLOCK_OPT_SIZE);
     if (size && size->value.n == -1) {
         if (backing_file && backing_file->value.s) {
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index 9507aef..f1688ab 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -52,7 +52,7 @@ int qcow2_refcount_init(BlockDriverState *bs)
                          s->refcount_table, refcount_table_size2);
         if (ret != refcount_table_size2)
             goto fail;
-        for(i = 0; i < s->refcount_table_size; i++)
+        for (i = 0; i < s->refcount_table_size; i++)
             be64_to_cpus(&s->refcount_table[i]);
     }
     return 0;
@@ -104,7 +104,7 @@ static int get_refcount(BlockDriverState *bs, int64_t 
cluster_index)
         return 0;
 
     ret = qcow2_cache_get(bs, s->refcount_block_cache, refcount_block_offset,
-        (void**) &refcount_block);
+        (void **) &refcount_block);
     if (ret < 0) {
         return ret;
     }
@@ -114,7 +114,7 @@ static int get_refcount(BlockDriverState *bs, int64_t 
cluster_index)
     refcount = be16_to_cpu(refcount_block[block_index]);
 
     ret = qcow2_cache_put(bs, s->refcount_block_cache,
-        (void**) &refcount_block);
+        (void **) &refcount_block);
     if (ret < 0) {
         return ret;
     }
@@ -176,8 +176,8 @@ static int alloc_refcount_block(BlockDriverState *bs,
 
         /* If it's already there, we're done */
         if (refcount_block_offset) {
-             return load_refcount_block(bs, refcount_block_offset,
-                 (void**) refcount_block);
+            return load_refcount_block(bs, refcount_block_offset,
+                                       (void **) refcount_block);
         }
     }
 
@@ -227,7 +227,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
     if (in_same_refcount_block(s, new_block, cluster_index << 
s->cluster_bits)) {
         /* Zero the new refcount block before updating it */
         ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
-            (void**) refcount_block);
+            (void **) refcount_block);
         if (ret < 0) {
             goto fail_block;
         }
@@ -255,7 +255,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         /* Initialize the new refcount block only after updating its refcount,
          * update_refcount uses the refcount cache itself */
         ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
-            (void**) refcount_block);
+            (void **) refcount_block);
         if (ret < 0) {
             goto fail_block;
         }
@@ -289,7 +289,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         return -EAGAIN;
     }
 
-    ret = qcow2_cache_put(bs, s->refcount_block_cache, (void**) 
refcount_block);
+    ret = qcow2_cache_put(bs, s->refcount_block_cache, (void **) 
refcount_block);
     if (ret < 0) {
         goto fail_block;
     }
@@ -357,7 +357,8 @@ static int alloc_refcount_block(BlockDriverState *bs,
     }
 
     /* Fill the refcount blocks */
-    uint64_t table_clusters = size_to_clusters(s, table_size * 
sizeof(uint64_t));
+    uint64_t table_clusters = size_to_clusters(s,
+                                               table_size * sizeof(uint64_t));
     int block = 0;
     for (i = 0; i < table_clusters + blocks_clusters; i++) {
         new_blocks[block++] = cpu_to_be16(1);
@@ -373,7 +374,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
     }
 
     /* Write refcount table to disk */
-    for(i = 0; i < table_size; i++) {
+    for (i = 0; i < table_size; i++) {
         cpu_to_be64s(&new_table[i]);
     }
 
@@ -384,14 +385,14 @@ static int alloc_refcount_block(BlockDriverState *bs,
         goto fail_table;
     }
 
-    for(i = 0; i < table_size; i++) {
+    for (i = 0; i < table_size; i++) {
         be64_to_cpus(&new_table[i]);
     }
 
     /* Hook up the new refcount table in the qcow2 header */
     uint8_t data[12];
-    cpu_to_be64w((uint64_t*)data, table_offset);
-    cpu_to_be32w((uint32_t*)(data + 8), table_clusters);
+    cpu_to_be64w((uint64_t *)data, table_offset);
+    cpu_to_be32w((uint32_t *)(data + 8), table_clusters);
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, 
refcount_table_offset),
         data, sizeof(data));
@@ -412,7 +413,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
     qcow2_free_clusters(bs, old_table_offset, old_table_size * 
sizeof(uint64_t),
                         QCOW2_DISCARD_OTHER);
 
-    ret = load_refcount_block(bs, new_block, (void**) refcount_block);
+    ret = load_refcount_block(bs, new_block, (void **) refcount_block);
     if (ret < 0) {
         return ret;
     }
@@ -426,7 +427,7 @@ fail_table:
     g_free(new_table);
 fail_block:
     if (*refcount_block != NULL) {
-        qcow2_cache_put(bs, s->refcount_block_cache, (void**) refcount_block);
+        qcow2_cache_put(bs, s->refcount_block_cache, (void **) refcount_block);
     }
     return ret;
 }
@@ -484,8 +485,7 @@ found:
     QTAILQ_FOREACH_SAFE(p, &s->discards, next, next) {
         if (p == d
             || p->offset > d->offset + d->bytes
-            || d->offset > p->offset + p->bytes)
-        {
+            || d->offset > p->offset + p->bytes) {
             continue;
         }
 
@@ -510,8 +510,8 @@ static int QEMU_WARN_UNUSED_RESULT 
update_refcount(BlockDriverState *bs,
     int ret;
 
 #ifdef DEBUG_ALLOC2
-    fprintf(stderr, "update_refcount: offset=%" PRId64 " size=%" PRId64 " 
addend=%d\n",
-           offset, length, addend);
+    fprintf(stderr, "update_refcount: offset=%" PRId64 " size=%" PRId64
+            " addend=%d\n", offset, length, addend);
 #endif
     if (length < 0) {
         return -EINVAL;
@@ -526,9 +526,8 @@ static int QEMU_WARN_UNUSED_RESULT 
update_refcount(BlockDriverState *bs,
 
     start = start_of_cluster(s, offset);
     last = start_of_cluster(s, offset + length - 1);
-    for(cluster_offset = start; cluster_offset <= last;
-        cluster_offset += s->cluster_size)
-    {
+    for (cluster_offset = start; cluster_offset <= last;
+         cluster_offset += s->cluster_size) {
         int block_index, refcount;
         int64_t cluster_index = cluster_offset >> s->cluster_bits;
         int64_t table_index =
@@ -538,7 +537,7 @@ static int QEMU_WARN_UNUSED_RESULT 
update_refcount(BlockDriverState *bs,
         if (table_index != old_table_index) {
             if (refcount_block) {
                 ret = qcow2_cache_put(bs, s->refcount_block_cache,
-                    (void**) &refcount_block);
+                    (void **) &refcount_block);
                 if (ret < 0) {
                     goto fail;
                 }
@@ -583,7 +582,7 @@ fail:
     if (refcount_block) {
         int wret;
         wret = qcow2_cache_put(bs, s->refcount_block_cache,
-            (void**) &refcount_block);
+            (void **) &refcount_block);
         if (wret < 0) {
             return ret < 0 ? ret : wret;
         }
@@ -643,7 +642,7 @@ static int64_t alloc_clusters_noref(BlockDriverState *bs, 
uint64_t size)
 
     nb_clusters = size_to_clusters(s, size);
 retry:
-    for(i = 0; i < nb_clusters; i++) {
+    for (i = 0; i < nb_clusters; i++) {
         uint64_t next_cluster_index = s->free_cluster_index++;
         refcount = get_refcount(bs, next_cluster_index);
 
@@ -657,8 +656,7 @@ retry:
     /* Make sure that all offsets in the "allocated" range are representable
      * in an int64_t */
     if (s->free_cluster_index > 0 &&
-        s->free_cluster_index - 1 > (INT64_MAX >> s->cluster_bits))
-    {
+        s->free_cluster_index - 1 > (INT64_MAX >> s->cluster_bits)) {
         return -EFBIG;
     }
 
@@ -708,7 +706,7 @@ int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t 
offset,
     do {
         /* Check how many clusters there are free */
         cluster_index = offset >> s->cluster_bits;
-        for(i = 0; i < nb_clusters; i++) {
+        for (i = 0; i < nb_clusters; i++) {
             refcount = get_refcount(bs, cluster_index++);
 
             if (refcount < 0) {
@@ -795,7 +793,7 @@ void qcow2_free_clusters(BlockDriverState *bs,
     BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_FREE);
     ret = update_refcount(bs, offset, size, -1, type);
     if (ret < 0) {
-        fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret));
+        error_report("qcow2_free_clusters failed: %s", strerror(-ret));
         /* TODO Remember the clusters to free them later and avoid leaking */
     }
 }
@@ -869,7 +867,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
             goto fail;
         }
 
-        for(i = 0;i < l1_size; i++)
+        for (i = 0; i < l1_size; i++)
             be64_to_cpus(&l1_table[i]);
     } else {
         assert(l1_size == s->l1_size);
@@ -877,19 +875,19 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
         l1_allocated = 0;
     }
 
-    for(i = 0; i < l1_size; i++) {
+    for (i = 0; i < l1_size; i++) {
         l2_offset = l1_table[i];
         if (l2_offset) {
             old_l2_offset = l2_offset;
             l2_offset &= L1E_OFFSET_MASK;
 
             ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
-                (void**) &l2_table);
+                (void **) &l2_table);
             if (ret < 0) {
                 goto fail;
             }
 
-            for(j = 0; j < s->l2_size; j++) {
+            for (j = 0; j < s->l2_size; j++) {
                 uint64_t cluster_index;
 
                 offset = be64_to_cpu(l2_table[j]);
@@ -897,50 +895,50 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
                 offset &= ~QCOW_OFLAG_COPIED;
 
                 switch (qcow2_get_cluster_type(offset)) {
-                    case QCOW2_CLUSTER_COMPRESSED:
-                        nb_csectors = ((offset >> s->csize_shift) &
-                                       s->csize_mask) + 1;
-                        if (addend != 0) {
-                            ret = update_refcount(bs,
-                                (offset & s->cluster_offset_mask) & ~511,
-                                nb_csectors * 512, addend,
-                                QCOW2_DISCARD_SNAPSHOT);
-                            if (ret < 0) {
-                                goto fail;
-                            }
-                        }
-                        /* compressed clusters are never modified */
-                        refcount = 2;
-                        break;
-
-                    case QCOW2_CLUSTER_NORMAL:
-                    case QCOW2_CLUSTER_ZERO:
-                        cluster_index = (offset & L2E_OFFSET_MASK) >> 
s->cluster_bits;
-                        if (!cluster_index) {
-                            /* unallocated */
-                            refcount = 0;
-                            break;
-                        }
-                        if (addend != 0) {
-                            refcount = qcow2_update_cluster_refcount(bs,
-                                    cluster_index, addend,
-                                    QCOW2_DISCARD_SNAPSHOT);
-                        } else {
-                            refcount = get_refcount(bs, cluster_index);
-                        }
-
-                        if (refcount < 0) {
-                            ret = refcount;
+                case QCOW2_CLUSTER_COMPRESSED:
+                    nb_csectors = ((offset >> s->csize_shift) &
+                                   s->csize_mask) + 1;
+                    if (addend != 0) {
+                        ret = update_refcount(bs,
+                            (offset & s->cluster_offset_mask) & ~511,
+                            nb_csectors * 512, addend,
+                            QCOW2_DISCARD_SNAPSHOT);
+                        if (ret < 0) {
                             goto fail;
                         }
-                        break;
-
-                    case QCOW2_CLUSTER_UNALLOCATED:
+                    }
+                    /* compressed clusters are never modified */
+                    refcount = 2;
+                    break;
+
+                case QCOW2_CLUSTER_NORMAL:
+                case QCOW2_CLUSTER_ZERO:
+                    cluster_index = (offset & L2E_OFFSET_MASK) >> 
s->cluster_bits;
+                    if (!cluster_index) {
+                        /* unallocated */
                         refcount = 0;
                         break;
+                    }
+                    if (addend != 0) {
+                        refcount = qcow2_update_cluster_refcount(bs,
+                                cluster_index, addend,
+                                QCOW2_DISCARD_SNAPSHOT);
+                    } else {
+                        refcount = get_refcount(bs, cluster_index);
+                    }
 
-                    default:
-                        abort();
+                    if (refcount < 0) {
+                        ret = refcount;
+                        goto fail;
+                    }
+                    break;
+
+                case QCOW2_CLUSTER_UNALLOCATED:
+                    refcount = 0;
+                    break;
+
+                default:
+                    abort();
                 }
 
                 if (refcount == 1) {
@@ -956,7 +954,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
                 }
             }
 
-            ret = qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
+            ret = qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
             if (ret < 0) {
                 goto fail;
             }
@@ -984,7 +982,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
     ret = bdrv_flush(bs);
 fail:
     if (l2_table) {
-        qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
+        qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
     }
 
     s->cache_discards = false;
@@ -1036,18 +1034,18 @@ static void inc_refcounts(BlockDriverState *bs,
 
     start = start_of_cluster(s, offset);
     last = start_of_cluster(s, offset + size - 1);
-    for(cluster_offset = start; cluster_offset <= last;
+    for (cluster_offset = start; cluster_offset <= last;
         cluster_offset += s->cluster_size) {
         k = cluster_offset >> s->cluster_bits;
         if (k >= refcount_table_size) {
-            fprintf(stderr, "Warning: cluster offset=0x%" PRIx64 " is after "
-                "the end of the image file, can't properly check refcounts.\n",
-                cluster_offset);
+            error_report("Warning: cluster offset=0x%" PRIx64 " is after "
+                         "the end of the image file, can't properly check 
refcounts.",
+                         cluster_offset);
             res->check_errors++;
         } else {
             if (++refcount_table[k] == 0) {
-                fprintf(stderr, "ERROR: overflow cluster offset=0x%" PRIx64
-                    "\n", cluster_offset);
+                error_report("ERROR: overflow cluster offset=0x%" PRIx64,
+                             cluster_offset);
                 res->corruptions++;
             }
         }
@@ -1084,16 +1082,16 @@ static int check_refcounts_l2(BlockDriverState *bs, 
BdrvCheckResult *res,
         goto fail;
 
     /* Do the actual checks */
-    for(i = 0; i < s->l2_size; i++) {
+    for (i = 0; i < s->l2_size; i++) {
         l2_entry = be64_to_cpu(l2_table[i]);
 
         switch (qcow2_get_cluster_type(l2_entry)) {
         case QCOW2_CLUSTER_COMPRESSED:
             /* Compressed clusters don't have QCOW_OFLAG_COPIED */
             if (l2_entry & QCOW_OFLAG_COPIED) {
-                fprintf(stderr, "ERROR: cluster %" PRId64 ": "
-                    "copied flag must never be set for compressed "
-                    "clusters\n", l2_entry >> s->cluster_bits);
+                error_report("ERROR: cluster %" PRId64 ": "
+                             "copied flag must never be set for compressed "
+                             "clusters", l2_entry >> s->cluster_bits);
                 l2_entry &= ~QCOW_OFLAG_COPIED;
                 res->corruptions++;
             }
@@ -1138,13 +1136,13 @@ static int check_refcounts_l2(BlockDriverState *bs, 
BdrvCheckResult *res,
             }
 
             /* Mark cluster as used */
-            inc_refcounts(bs, res, refcount_table,refcount_table_size,
+            inc_refcounts(bs, res, refcount_table, refcount_table_size,
                 offset, s->cluster_size);
 
             /* Correct offsets are cluster aligned */
             if (offset_into_cluster(s, offset)) {
-                fprintf(stderr, "ERROR offset=%" PRIx64 ": Cluster is not "
-                    "properly aligned; L2 entry corrupted.\n", offset);
+                error_report("ERROR offset=%" PRIx64 ": Cluster is not "
+                             "properly aligned; L2 entry corrupted.", offset);
                 res->corruptions++;
             }
             break;
@@ -1162,7 +1160,7 @@ static int check_refcounts_l2(BlockDriverState *bs, 
BdrvCheckResult *res,
     return 0;
 
 fail:
-    fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
+    error_report("ERROR: I/O error in check_refcounts_l2");
     g_free(l2_table);
     return -EIO;
 }
@@ -1200,12 +1198,12 @@ static int check_refcounts_l1(BlockDriverState *bs,
         if (bdrv_pread(bs->file, l1_table_offset,
                        l1_table, l1_size2) != l1_size2)
             goto fail;
-        for(i = 0;i < l1_size; i++)
+        for (i = 0; i < l1_size; i++)
             be64_to_cpus(&l1_table[i]);
     }
 
     /* Do the actual checks */
-    for(i = 0; i < l1_size; i++) {
+    for (i = 0; i < l1_size; i++) {
         l2_offset = l1_table[i];
         if (l2_offset) {
             /* Mark L2 table as used */
@@ -1215,8 +1213,8 @@ static int check_refcounts_l1(BlockDriverState *bs,
 
             /* L2 tables are cluster aligned */
             if (offset_into_cluster(s, l2_offset)) {
-                fprintf(stderr, "ERROR l2_offset=%" PRIx64 ": Table is not "
-                    "cluster aligned; L1 entry corrupted\n", l2_offset);
+                error_report("ERROR l2_offset=%" PRIx64 ": Table is not "
+                             "cluster aligned; L1 entry corrupted", l2_offset);
                 res->corruptions++;
             }
 
@@ -1232,7 +1230,7 @@ static int check_refcounts_l1(BlockDriverState *bs,
     return 0;
 
 fail:
-    fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
+    error_report("ERROR: I/O error in check_refcounts_l1");
     res->check_errors++;
     g_free(l1_table);
     return -EIO;
@@ -1270,11 +1268,11 @@ static int check_oflag_copied(BlockDriverState *bs, 
BdrvCheckResult *res,
             continue;
         }
         if ((refcount == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
-            fprintf(stderr, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
-                    "l1_entry=%" PRIx64 " refcount=%d\n",
-                    fix & BDRV_FIX_ERRORS ? "Repairing" :
-                                            "ERROR",
-                    i, l1_entry, refcount);
+            error_report("%s OFLAG_COPIED L2 cluster: l1_index=%d "
+                         "l1_entry=%" PRIx64 " refcount=%d",
+                         fix & BDRV_FIX_ERRORS ? "Repairing" :
+                                                 "ERROR",
+                         i, l1_entry, refcount);
             if (fix & BDRV_FIX_ERRORS) {
                 s->l1_table[i] = refcount == 1
                                ? l1_entry |  QCOW_OFLAG_COPIED
@@ -1293,7 +1291,7 @@ static int check_oflag_copied(BlockDriverState *bs, 
BdrvCheckResult *res,
         ret = bdrv_pread(bs->file, l2_offset, l2_table,
                          s->l2_size * sizeof(uint64_t));
         if (ret < 0) {
-            fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
+            error_report("ERROR: Could not read L2 table: %s",
                     strerror(-ret));
             res->check_errors++;
             goto fail;
@@ -1312,11 +1310,11 @@ static int check_oflag_copied(BlockDriverState *bs, 
BdrvCheckResult *res,
                     continue;
                 }
                 if ((refcount == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
-                    fprintf(stderr, "%s OFLAG_COPIED data cluster: "
-                            "l2_entry=%" PRIx64 " refcount=%d\n",
-                            fix & BDRV_FIX_ERRORS ? "Repairing" :
-                                                    "ERROR",
-                            l2_entry, refcount);
+                    error_report("%s OFLAG_COPIED data cluster: "
+                                 "l2_entry=%" PRIx64 " refcount=%d",
+                                 fix & BDRV_FIX_ERRORS ? "Repairing" :
+                                                         "ERROR",
+                                 l2_entry, refcount);
                     if (fix & BDRV_FIX_ERRORS) {
                         l2_table[j] = cpu_to_be64(refcount == 1
                                     ? l2_entry |  QCOW_OFLAG_COPIED
@@ -1334,16 +1332,16 @@ static int check_oflag_copied(BlockDriverState *bs, 
BdrvCheckResult *res,
             ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
                                                 l2_offset, s->cluster_size);
             if (ret < 0) {
-                fprintf(stderr, "ERROR: Could not write L2 table; metadata "
-                        "overlap check failed: %s\n", strerror(-ret));
+                error_report("ERROR: Could not write L2 table; metadata "
+                             "overlap check failed: %s", strerror(-ret));
                 res->check_errors++;
                 goto fail;
             }
 
             ret = bdrv_pwrite(bs->file, l2_offset, l2_table, s->cluster_size);
             if (ret < 0) {
-                fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
-                        strerror(-ret));
+                error_report("ERROR: Could not write L2 table: %s",
+                             strerror(-ret));
                 res->check_errors++;
                 goto fail;
             }
@@ -1409,8 +1407,8 @@ static int64_t realloc_refcount_block(BlockDriverState 
*bs, int reftable_index,
     /* allocate new refcount block */
     new_offset = qcow2_alloc_clusters(bs, s->cluster_size);
     if (new_offset < 0) {
-        fprintf(stderr, "Could not allocate new cluster: %s\n",
-                strerror(-new_offset));
+        error_report("Could not allocate new cluster: %s",
+                     strerror(-new_offset));
         ret = new_offset;
         goto done;
     }
@@ -1418,7 +1416,7 @@ static int64_t realloc_refcount_block(BlockDriverState 
*bs, int reftable_index,
     /* fetch current refcount block content */
     ret = qcow2_cache_get(bs, s->refcount_block_cache, offset, 
&refcount_block);
     if (ret < 0) {
-        fprintf(stderr, "Could not fetch refcount block: %s\n", 
strerror(-ret));
+        error_report("Could not fetch refcount block: %s", strerror(-ret));
         goto fail_free_cluster;
     }
 
@@ -1426,8 +1424,8 @@ static int64_t realloc_refcount_block(BlockDriverState 
*bs, int reftable_index,
      * no refcount block yet (regarding this check) */
     ret = qcow2_pre_write_overlap_check(bs, 0, new_offset, s->cluster_size);
     if (ret < 0) {
-        fprintf(stderr, "Could not write refcount block; metadata overlap "
-                "check failed: %s\n", strerror(-ret));
+        error_report("Could not write refcount block; metadata overlap "
+                     "check failed: %s", strerror(-ret));
         /* the image will be marked corrupt, so don't even attempt on freeing
          * the cluster */
         goto done;
@@ -1437,7 +1435,7 @@ static int64_t realloc_refcount_block(BlockDriverState 
*bs, int reftable_index,
     ret = bdrv_write(bs->file, new_offset / BDRV_SECTOR_SIZE, refcount_block,
             s->cluster_sectors);
     if (ret < 0) {
-        fprintf(stderr, "Could not write refcount block: %s\n", 
strerror(-ret));
+        error_report("Could not write refcount block: %s", strerror(-ret));
         goto fail_free_cluster;
     }
 
@@ -1446,8 +1444,8 @@ static int64_t realloc_refcount_block(BlockDriverState 
*bs, int reftable_index,
     s->refcount_table[reftable_index] = new_offset;
     ret = write_reftable_entry(bs, reftable_index);
     if (ret < 0) {
-        fprintf(stderr, "Could not update refcount table: %s\n",
-                strerror(-ret));
+        error_report("Could not update refcount table: %s",
+                     strerror(-ret));
         goto fail_free_cluster;
     }
 
@@ -1517,10 +1515,10 @@ int qcow2_check_refcounts(BlockDriverState *bs, 
BdrvCheckResult *res,
     }
 
     /* snapshots */
-    for(i = 0; i < s->nb_snapshots; i++) {
+    for (i = 0; i < s->nb_snapshots; i++) {
         sn = s->snapshots + i;
         ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
-            sn->l1_table_offset, sn->l1_size, 0);
+                                 sn->l1_table_offset, sn->l1_size, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -1533,22 +1531,22 @@ int qcow2_check_refcounts(BlockDriverState *bs, 
BdrvCheckResult *res,
         s->refcount_table_offset,
         s->refcount_table_size * sizeof(uint64_t));
 
-    for(i = 0; i < s->refcount_table_size; i++) {
+    for (i = 0; i < s->refcount_table_size; i++) {
         uint64_t offset, cluster;
         offset = s->refcount_table[i];
         cluster = offset >> s->cluster_bits;
 
         /* Refcount blocks are cluster aligned */
         if (offset_into_cluster(s, offset)) {
-            fprintf(stderr, "ERROR refcount block %" PRId64 " is not "
-                "cluster aligned; refcount table entry corrupted\n", i);
+            error_report("ERROR refcount block %" PRId64 " is not "
+                         "cluster aligned; refcount table entry corrupted", i);
             res->corruptions++;
             continue;
         }
 
         if (cluster >= nb_clusters) {
-            fprintf(stderr, "ERROR refcount block %" PRId64
-                    " is outside image\n", i);
+            error_report("ERROR refcount block %" PRId64
+                        " is outside image", i);
             res->corruptions++;
             continue;
         }
@@ -1557,11 +1555,11 @@ int qcow2_check_refcounts(BlockDriverState *bs, 
BdrvCheckResult *res,
             inc_refcounts(bs, res, refcount_table, nb_clusters,
                 offset, s->cluster_size);
             if (refcount_table[cluster] != 1) {
-                fprintf(stderr, "%s refcount block %" PRId64
-                    " refcount=%d\n",
-                    fix & BDRV_FIX_ERRORS ? "Repairing" :
-                                            "ERROR",
-                    i, refcount_table[cluster]);
+                error_report("%s refcount block %" PRId64
+                             " refcount=%d",
+                             fix & BDRV_FIX_ERRORS ? "Repairing" :
+                                                     "ERROR",
+                             i, refcount_table[cluster]);
 
                 if (fix & BDRV_FIX_ERRORS) {
                     int64_t new_offset;
@@ -1598,8 +1596,8 @@ int qcow2_check_refcounts(BlockDriverState *bs, 
BdrvCheckResult *res,
     for (i = 0, highest_cluster = 0; i < nb_clusters; i++) {
         refcount1 = get_refcount(bs, i);
         if (refcount1 < 0) {
-            fprintf(stderr, "Can't get refcount for cluster %" PRId64 ": %s\n",
-                i, strerror(-refcount1));
+            error_report("Can't get refcount for cluster %" PRId64 ": %s",
+                         i, strerror(-refcount1));
             res->check_errors++;
             continue;
         }
@@ -1620,11 +1618,11 @@ int qcow2_check_refcounts(BlockDriverState *bs, 
BdrvCheckResult *res,
                 num_fixed = &res->corruptions_fixed;
             }
 
-            fprintf(stderr, "%s cluster %" PRId64 " refcount=%d 
reference=%d\n",
-                   num_fixed != NULL     ? "Repairing" :
-                   refcount1 < refcount2 ? "ERROR" :
-                                           "Leaked",
-                   i, refcount1, refcount2);
+            error_report("%s cluster %" PRId64 " refcount=%d reference=%d",
+                         num_fixed != NULL     ? "Repairing" :
+                         refcount1 < refcount2 ? "ERROR" :
+                                                 "Leaked",
+                         i, refcount1, refcount2);
 
             if (num_fixed) {
                 ret = update_refcount(bs, i << s->cluster_bits, 1,
@@ -1811,9 +1809,9 @@ int qcow2_pre_write_overlap_check(BlockDriverState *bs, 
int ign, int64_t offset,
 
         assert(metadata_ol_bitnr < QCOW2_OL_MAX_BITNR);
 
-        fprintf(stderr, "qcow2: Preventing invalid write on metadata (overlaps 
"
-                "with %s); image marked as corrupt.\n",
-                metadata_ol_names[metadata_ol_bitnr]);
+        error_report("qcow2: Preventing invalid write on metadata (overlaps "
+                     "with %s); image marked as corrupt.",
+                     metadata_ol_names[metadata_ol_bitnr]);
         message = g_strdup_printf("Prevented %s overwrite",
                 metadata_ol_names[metadata_ol_bitnr]);
         data = qobject_from_jsonf("{ 'device': %s, 'msg': %s, 'offset': %"
diff --git a/block/qcow2.c b/block/qcow2.c
index a4b97e8..7877031 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -71,7 +71,7 @@ static int qcow2_probe(const uint8_t *buf, int buf_size, 
const char *filename)
 }
 
 
-/* 
+/*
  * read qcow2 extension and fill bs
  * start reading from start_offset
  * finish reading upon magic of value 0 or when end_offset reached
@@ -88,7 +88,8 @@ static int qcow2_read_extensions(BlockDriverState *bs, 
uint64_t start_offset,
     int ret;
 
 #ifdef DEBUG_EXT
-    printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, 
end_offset);
+    printf("qcow2_read_extensions: start=%ld end=%ld\n",
+           start_offset, end_offset);
 #endif
     offset = start_offset;
     while (offset < end_offset) {
@@ -143,7 +144,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, 
uint64_t start_offset,
 
         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
             if (p_feature_table != NULL) {
-                void* feature_table = g_malloc0(ext.len + 2 * 
sizeof(Qcow2Feature));
+                void *feature_table = g_malloc0(ext.len + 2 * 
sizeof(Qcow2Feature));
                 ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
                 if (ret < 0) {
                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
@@ -684,7 +685,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, 
int flags,
             error_setg_errno(errp, -ret, "Could not read L1 table");
             goto fail;
         }
-        for(i = 0;i < s->l1_size; i++) {
+        for(i = 0; i < s->l1_size; i++) {
             be64_to_cpus(&s->l1_table[i]);
         }
     }
@@ -874,8 +875,9 @@ static int qcow2_set_key(BlockDriverState *bs, const char 
*key)
     if (len > 16)
         len = 16;
     /* XXX: we could compress the chars to 7 bits to increase
-       entropy */
-    for(i = 0;i < len;i++) {
+     * entropy
+     */
+    for (i = 0; i < len; i++) {
         keybuf[i] = key[i];
     }
     s->crypt_method = s->crypt_method_header;
@@ -1330,7 +1332,7 @@ static void qcow2_invalidate_cache(BlockDriverState *bs, 
Error **errp)
 static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
     size_t len, size_t buflen)
 {
-    QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
+    QCowExtension *ext_backing_fmt = (QCowExtension *) buf;
     size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
 
     if (buflen < ext_len) {
@@ -1369,7 +1371,7 @@ int qcow2_update_header(BlockDriverState *bs)
     buf = qemu_blockalign(bs, buflen);
 
     /* Header structure */
-    header = (QCowHeader*) buf;
+    header = (QCowHeader *) buf;
 
     if (buflen < sizeof(*header)) {
         ret = -ENOSPC;
@@ -1505,7 +1507,7 @@ int qcow2_update_header(BlockDriverState *bs)
         /* Using strncpy is ok here, since buf is not NUL-terminated. */
         strncpy(buf, bs->backing_file, buflen);
 
-        header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
+        header->backing_file_offset = cpu_to_be64(buf - ((char *) header));
         header->backing_file_size   = cpu_to_be32(backing_file_len);
     }
 
@@ -1602,8 +1604,7 @@ static int qcow2_create2(const char *filename, int64_t 
total_size,
     int cluster_bits;
     cluster_bits = ffs(cluster_size) - 1;
     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
-        (1 << cluster_bits) != cluster_size)
-    {
+        (1 << cluster_bits) != cluster_size) {
         error_setg(errp, "Cluster size must be a power of two between %d and "
                    "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
         return -EINVAL;
@@ -1621,9 +1622,9 @@ static int qcow2_create2(const char *filename, int64_t 
total_size,
      * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
      * size for any qcow2 image.
      */
-    BlockDriverState* bs;
+    BlockDriverState *bs;
     QCowHeader *header;
-    uint64_t* refcount_table;
+    uint64_t *refcount_table;
     Error *local_err = NULL;
     int ret;
 
@@ -1694,7 +1695,7 @@ static int qcow2_create2(const char *filename, int64_t 
total_size,
      * refcount of the cluster that is occupied by the header and the refcount
      * table)
      */
-    BlockDriver* drv = bdrv_find_format("qcow2");
+    BlockDriver *drv = bdrv_find_format("qcow2");
     assert(drv != NULL);
     ret = bdrv_open(&bs, filename, NULL, NULL,
         BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, drv, &local_err);
@@ -2054,11 +2055,11 @@ static ImageInfoSpecific 
*qcow2_get_specific_info(BlockDriverState *bs)
         },
     };
     if (s->qcow_version == 2) {
-        *spec_info->qcow2 = (ImageInfoSpecificQCow2){
+        *spec_info->qcow2 = (ImageInfoSpecificQCow2) {
             .compat = g_strdup("0.10"),
         };
     } else if (s->qcow_version == 3) {
-        *spec_info->qcow2 = (ImageInfoSpecificQCow2){
+        *spec_info->qcow2 = (ImageInfoSpecificQCow2) {
             .compat             = g_strdup("1.1"),
             .lazy_refcounts     = s->compatible_features &
                                   QCOW2_COMPAT_LAZY_REFCOUNTS,
@@ -2210,8 +2211,7 @@ static int qcow2_amend_options(BlockDriverState *bs,
     int ret;
     int i;
 
-    for (i = 0; options[i].name; i++)
-    {
+    for (i = 0; options[i].name; i++) {
         if (!options[i].assigned) {
             /* only change explicitly defined options */
             continue;
@@ -2225,12 +2225,12 @@ static int qcow2_amend_options(BlockDriverState *bs,
             } else if (!strcmp(options[i].value.s, "1.1")) {
                 new_version = 3;
             } else {
-                fprintf(stderr, "Unknown compatibility level %s.\n",
-                        options[i].value.s);
+                error_report("Unknown compatibility level %s.",
+                             options[i].value.s);
                 return -EINVAL;
             }
         } else if (!strcmp(options[i].name, "preallocation")) {
-            fprintf(stderr, "Cannot change preallocation mode.\n");
+            error_report("Cannot change preallocation mode.");
             return -ENOTSUP;
         } else if (!strcmp(options[i].name, "size")) {
             new_size = options[i].value.n;
@@ -2240,14 +2240,14 @@ static int qcow2_amend_options(BlockDriverState *bs,
             backing_format = options[i].value.s;
         } else if (!strcmp(options[i].name, "encryption")) {
             if ((options[i].value.n != !!s->crypt_method)) {
-                fprintf(stderr, "Changing the encryption flag is not "
-                        "supported.\n");
+                error_report("Changing the encryption flag is not "
+                             "supported.");
                 return -ENOTSUP;
             }
         } else if (!strcmp(options[i].name, "cluster_size")) {
             if (options[i].value.n != s->cluster_size) {
-                fprintf(stderr, "Changing the cluster size is not "
-                        "supported.\n");
+                error_report("Changing the cluster size is not "
+                             "supported.");
                 return -ENOTSUP;
             }
         } else if (!strcmp(options[i].name, "lazy_refcounts")) {
@@ -2287,8 +2287,8 @@ static int qcow2_amend_options(BlockDriverState *bs,
     if (s->use_lazy_refcounts != lazy_refcounts) {
         if (lazy_refcounts) {
             if (s->qcow_version < 3) {
-                fprintf(stderr, "Lazy refcounts only supported with 
compatibility "
-                        "level 1.1 and above (use compat=1.1 or greater)\n");
+                error_report("Lazy refcounts only supported with compatibility 
"
+                             "level 1.1 and above (use compat=1.1 or 
greater)");
                 return -EINVAL;
             }
             s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
diff --git a/block/raw-posix.c b/block/raw-posix.c
index 6586a0c..96b61a9 100644
--- a/block/raw-posix.c
+++ b/block/raw-posix.c
@@ -39,7 +39,7 @@
 #include <IOKit/storage/IOMediaBSDClient.h>
 #include <IOKit/storage/IOMedia.h>
 #include <IOKit/storage/IOCDMedia.h>
-//#include <IOKit/storage/IOCDTypes.h>
+/* #include <IOKit/storage/IOCDTypes.h> */
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
@@ -62,7 +62,7 @@
 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
 #include <linux/falloc.h>
 #endif
-#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 #include <sys/disk.h>
 #include <sys/cdio.h>
 #endif
@@ -89,9 +89,9 @@
 #include <xfs/xfs.h>
 #endif
 
-//#define DEBUG_FLOPPY
+/* #define DEBUG_FLOPPY */
 
-//#define DEBUG_BLOCK
+/* #define DEBUG_BLOCK */
 #if defined(DEBUG_BLOCK)
 #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
     { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
@@ -121,7 +121,7 @@
    reopen it to see if the disk has been changed */
 #define FD_OPEN_TIMEOUT (1000000000)
 
-#define MAX_BLOCKSIZE  4096
+#define MAX_BLOCKSIZE 4096
 
 typedef struct BDRVRawState {
     int fd;
@@ -190,8 +190,8 @@ static int raw_normalize_devicepath(const char **filename)
     fname = *filename;
     dp = strrchr(fname, '/');
     if (lstat(fname, &sb) < 0) {
-        fprintf(stderr, "%s: stat failed: %s\n",
-            fname, strerror(errno));
+        error_report("%s: stat failed: %s",
+                     fname, strerror(errno));
         return -errno;
     }
 
@@ -205,9 +205,9 @@ static int raw_normalize_devicepath(const char **filename)
         snprintf(namebuf, PATH_MAX, "%.*s/r%s",
             (int)(dp - fname), fname, dp + 1);
     }
-    fprintf(stderr, "%s is a block device", fname);
+
     *filename = namebuf;
-    fprintf(stderr, ", using %s\n", *filename);
+    error_report("%s is a block device, using %s", fname, *filename);
 
     return 0;
 }
@@ -725,7 +725,7 @@ static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
          * we can just use plain pread/pwrite without any problems.
          */
         if (aiocb->aio_niov == 1) {
-             return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
+            return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
         }
         /*
          * We have more than one iovec, and all are properly aligned.
@@ -945,7 +945,7 @@ static int aio_worker(void *arg)
         ret = handle_aiocb_write_zeroes(aiocb);
         break;
     default:
-        fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
+        error_report("invalid aio request (0x%x)", aiocb->aio_type);
         ret = -EINVAL;
         break;
     }
@@ -1079,9 +1079,9 @@ static int raw_truncate(BlockDriverState *bs, int64_t 
offset)
             return -errno;
         }
     } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
-       if (offset > raw_getlength(bs)) {
-           return -EINVAL;
-       }
+        if (offset > raw_getlength(bs)) {
+            return -EINVAL;
+        }
     } else {
         return -ENOTSUP;
     }
@@ -1166,7 +1166,7 @@ static int64_t raw_getlength(BlockDriverState *bs)
     int fd = s->fd;
     int64_t size;
     struct stat sb;
-#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
     int reopened = 0;
 #endif
     int ret;
@@ -1175,12 +1175,12 @@ static int64_t raw_getlength(BlockDriverState *bs)
     if (ret < 0)
         return ret;
 
-#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 again:
 #endif
     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
 #ifdef DIOCGMEDIASIZE
-       if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
+    if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
 #elif defined(DIOCGPART)
         {
                 struct partinfo pi;
@@ -1197,7 +1197,7 @@ again:
         size = lseek(fd, 0LL, SEEK_END);
 #endif
 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-        switch(s->type) {
+        switch (s->type) {
         case FTYPE_CD:
             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
             if (size == 2048LL * (unsigned)-1)
@@ -1485,56 +1485,60 @@ static BlockDriver bdrv_file = {
 /* host device */
 
 #if defined(__APPLE__) && defined(__MACH__)
-static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
-static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, 
CFIndex maxPathSize );
+static kern_return_t FindEjectableCDMedia(io_iterator_t *mediaIterator);
+static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
+                                CFIndex maxPathSize);
 
-kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
+kern_return_t FindEjectableCDMedia(io_iterator_t *mediaIterator)
 {
     kern_return_t       kernResult;
     mach_port_t     masterPort;
     CFMutableDictionaryRef  classesToMatch;
 
-    kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
+    kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort);
     if ( KERN_SUCCESS != kernResult ) {
-        printf( "IOMasterPort returned %d\n", kernResult );
+        printf("IOMasterPort returned %d\n", kernResult);
     }
 
-    classesToMatch = IOServiceMatching( kIOCDMediaClass );
-    if ( classesToMatch == NULL ) {
-        printf( "IOServiceMatching returned a NULL dictionary.\n" );
+    classesToMatch = IOServiceMatching(kIOCDMediaClass);
+    if (classesToMatch == NULL) {
+        printf("IOServiceMatching returned a NULL dictionary.\n");
     } else {
-    CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), 
kCFBooleanTrue );
+        CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
+                             kCFBooleanTrue);
     }
-    kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, 
mediaIterator );
-    if ( KERN_SUCCESS != kernResult )
+    kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
+                                              mediaIterator);
+    if (KERN_SUCCESS != kernResult)
     {
-        printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
+        printf("IOServiceGetMatchingServices returned %d\n", kernResult);
     }
 
     return kernResult;
 }
 
-kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex 
maxPathSize )
+kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath, CFIndex 
maxPathSize)
 {
     io_object_t     nextMedia;
     kern_return_t   kernResult = KERN_FAILURE;
     *bsdPath = '\0';
-    nextMedia = IOIteratorNext( mediaIterator );
-    if ( nextMedia )
-    {
+    nextMedia = IOIteratorNext(mediaIterator);
+    if (nextMedia) {
         CFTypeRef   bsdPathAsCFString;
-    bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( 
kIOBSDNameKey ), kCFAllocatorDefault, 0 );
-        if ( bsdPathAsCFString ) {
+        bsdPathAsCFString = IORegistryEntryCreateCFProperty(nextMedia,
+                                CFSTR(kIOBSDNameKey), kCFAllocatorDefault, 0);
+        if (bsdPathAsCFString) {
             size_t devPathLength;
-            strcpy( bsdPath, _PATH_DEV );
-            strcat( bsdPath, "r" );
-            devPathLength = strlen( bsdPath );
-            if ( CFStringGetCString( bsdPathAsCFString, bsdPath + 
devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
+            strcpy(bsdPath, _PATH_DEV);
+            strcat(bsdPath, "r");
+            devPathLength = strlen(bsdPath);
+            if (CFStringGetCString(bsdPathAsCFString, bsdPath + devPathLength,
+                    maxPathSize - devPathLength, kCFStringEncodingASCII)) {
                 kernResult = KERN_SUCCESS;
             }
-            CFRelease( bsdPathAsCFString );
+            CFRelease(bsdPathAsCFString);
         }
-        IOObjectRelease( nextMedia );
+        IOObjectRelease(nextMedia);
     }
 
     return kernResult;
@@ -1612,13 +1616,13 @@ static int hdev_open(BlockDriverState *bs, QDict 
*options, int flags,
     if (strstart(filename, "/dev/cdrom", NULL)) {
         kern_return_t kernResult;
         io_iterator_t mediaIterator;
-        char bsdPath[ MAXPATHLEN ];
+        char bsdPath[MAXPATHLEN];
         int fd;
 
-        kernResult = FindEjectableCDMedia( &mediaIterator );
-        kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
+        kernResult = FindEjectableCDMedia(&mediaIterator);
+        kernResult = GetBSDPath(mediaIterator, bsdPath, sizeof(bsdPath));
 
-        if ( bsdPath[ 0 ] != '\0' ) {
+        if (bsdPath[0] != '\0') {
             strcat(bsdPath,"s0");
             /* some CDs don't have a partition 0 */
             fd = qemu_open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
@@ -1631,15 +1635,15 @@ static int hdev_open(BlockDriverState *bs, QDict 
*options, int flags,
             qdict_put(options, "filename", qstring_from_str(filename));
         }
 
-        if ( mediaIterator )
-            IOObjectRelease( mediaIterator );
+        if (mediaIterator)
+            IOObjectRelease(mediaIterator);
     }
 #endif
 
     s->type = FTYPE_FILE;
 #if defined(__linux__)
     {
-        char resolved_path[ MAXPATHLEN ], *temp;
+        char resolved_path[MAXPATHLEN], *temp;
 
         temp = realpath(filename, resolved_path);
         if (temp && strstart(temp, "/dev/sg", NULL)) {
@@ -1866,14 +1870,14 @@ static BlockDriver bdrv_host_device = {
     .create_options     = raw_create_options,
     .bdrv_co_write_zeroes = hdev_co_write_zeroes,
 
-    .bdrv_aio_readv    = raw_aio_readv,
-    .bdrv_aio_writev   = raw_aio_writev,
+    .bdrv_aio_readv = raw_aio_readv,
+    .bdrv_aio_writev = raw_aio_writev,
     .bdrv_aio_flush    = raw_aio_flush,
     .bdrv_aio_discard   = hdev_aio_discard,
     .bdrv_refresh_limits = raw_refresh_limits,
 
     .bdrv_truncate      = raw_truncate,
-    .bdrv_getlength    = raw_getlength,
+    .bdrv_getlength = raw_getlength,
     .bdrv_get_info = raw_get_info,
     .bdrv_get_allocated_file_size
                         = raw_get_allocated_file_size,
@@ -1999,7 +2003,7 @@ static BlockDriver bdrv_host_floppy = {
     .protocol_name      = "host_floppy",
     .instance_size      = sizeof(BDRVRawState),
     .bdrv_needs_filename = true,
-    .bdrv_probe_device = floppy_probe_device,
+    .bdrv_probe_device = floppy_probe_device,
     .bdrv_parse_filename = floppy_parse_filename,
     .bdrv_file_open     = floppy_open,
     .bdrv_close         = raw_close,
@@ -2011,7 +2015,7 @@ static BlockDriver bdrv_host_floppy = {
 
     .bdrv_aio_readv     = raw_aio_readv,
     .bdrv_aio_writev    = raw_aio_writev,
-    .bdrv_aio_flush    = raw_aio_flush,
+    .bdrv_aio_flush = raw_aio_flush,
     .bdrv_refresh_limits = raw_refresh_limits,
 
     .bdrv_truncate      = raw_truncate,
@@ -2124,7 +2128,7 @@ static BlockDriver bdrv_host_cdrom = {
     .protocol_name      = "host_cdrom",
     .instance_size      = sizeof(BDRVRawState),
     .bdrv_needs_filename = true,
-    .bdrv_probe_device = cdrom_probe_device,
+    .bdrv_probe_device = cdrom_probe_device,
     .bdrv_parse_filename = cdrom_parse_filename,
     .bdrv_file_open     = cdrom_open,
     .bdrv_close         = raw_close,
@@ -2136,7 +2140,7 @@ static BlockDriver bdrv_host_cdrom = {
 
     .bdrv_aio_readv     = raw_aio_readv,
     .bdrv_aio_writev    = raw_aio_writev,
-    .bdrv_aio_flush    = raw_aio_flush,
+    .bdrv_aio_flush = raw_aio_flush,
     .bdrv_refresh_limits = raw_refresh_limits,
 
     .bdrv_truncate      = raw_truncate,
@@ -2156,7 +2160,7 @@ static BlockDriver bdrv_host_cdrom = {
 };
 #endif /* __linux__ */
 
-#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
                       Error **errp)
 {
@@ -2255,7 +2259,7 @@ static BlockDriver bdrv_host_cdrom = {
     .protocol_name      = "host_cdrom",
     .instance_size      = sizeof(BDRVRawState),
     .bdrv_needs_filename = true,
-    .bdrv_probe_device = cdrom_probe_device,
+    .bdrv_probe_device = cdrom_probe_device,
     .bdrv_parse_filename = cdrom_parse_filename,
     .bdrv_file_open     = cdrom_open,
     .bdrv_close         = raw_close,
@@ -2267,7 +2271,7 @@ static BlockDriver bdrv_host_cdrom = {
 
     .bdrv_aio_readv     = raw_aio_readv,
     .bdrv_aio_writev    = raw_aio_writev,
-    .bdrv_aio_flush    = raw_aio_flush,
+    .bdrv_aio_flush = raw_aio_flush,
     .bdrv_refresh_limits = raw_refresh_limits,
 
     .bdrv_truncate      = raw_truncate,
diff --git a/block/raw-win32.c b/block/raw-win32.c
index 064ea31..78e3a9a 100644
--- a/block/raw-win32.c
+++ b/block/raw-win32.c
@@ -131,7 +131,7 @@ static int aio_worker(void *arg)
         }
         break;
     default:
-        fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
+        error_report("invalid aio request (0x%x)", aiocb->aio_type);
         ret = -EINVAL;
         break;
     }
@@ -172,21 +172,21 @@ int qemu_ftruncate64(int fd, int64_t length)
     BOOL res;
 
     if ((GetVersion() & 0x80000000UL) && (length >> 32) != 0)
-       return -1;
+        return -1;
 
     h = (HANDLE)_get_osfhandle(fd);
 
     /* get current position, ftruncate do not change position */
     li.HighPart = 0;
-    li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT);
+    li.LowPart = SetFilePointer(h, 0, &li.HighPart, FILE_CURRENT);
     if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
-       return -1;
+        return -1;
     }
 
     high = length >> 32;
     dw = SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN);
     if (dw == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
-       return -1;
+        return -1;
     }
     res = SetEndOfFile(h);
 
@@ -199,7 +199,7 @@ static int set_sparse(int fd)
 {
     DWORD returned;
     return (int) DeviceIoControl((HANDLE)_get_osfhandle(fd), FSCTL_SET_SPARSE,
-                                NULL, 0, NULL, 0, &returned, NULL);
+                                 NULL, 0, NULL, 0, &returned, NULL);
 }
 
 static void raw_probe_alignment(BlockDriverState *bs)
@@ -358,7 +358,7 @@ static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
     BDRVRawState *s = bs->opaque;
     if (s->aio) {
         return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
-                                nb_sectors, cb, opaque, QEMU_AIO_READ); 
+                                nb_sectors, cb, opaque, QEMU_AIO_READ);
     } else {
         return paio_submit(bs, s->hfile, sector_num, qiov, nb_sectors,
                            cb, opaque, QEMU_AIO_READ);
@@ -372,7 +372,7 @@ static BlockDriverAIOCB *raw_aio_writev(BlockDriverState 
*bs,
     BDRVRawState *s = bs->opaque;
     if (s->aio) {
         return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
-                                nb_sectors, cb, opaque, QEMU_AIO_WRITE); 
+                                nb_sectors, cb, opaque, QEMU_AIO_WRITE);
     } else {
         return paio_submit(bs, s->hfile, sector_num, qiov, nb_sectors,
                            cb, opaque, QEMU_AIO_WRITE);
@@ -410,11 +410,11 @@ static int raw_truncate(BlockDriverState *bs, int64_t 
offset)
      */
     dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN);
     if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
-        fprintf(stderr, "SetFilePointer error: %lu\n", GetLastError());
+        error_report("SetFilePointer error: %lu", GetLastError());
         return -EIO;
     }
     if (SetEndOfFile(s->hfile) == 0) {
-        fprintf(stderr, "SetEndOfFile error: %lu\n", GetLastError());
+        error_report("SetEndOfFile error: %lu", GetLastError());
         return -EIO;
     }
     return 0;
@@ -429,7 +429,7 @@ static int64_t raw_getlength(BlockDriverState *bs)
     DWORD count;
     BOOL status;
 
-    switch(s->type) {
+    switch (s->type) {
     case FTYPE_FILE:
         l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart);
         if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
@@ -456,7 +456,7 @@ static int64_t raw_getlength(BlockDriverState *bs)
 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
 {
     typedef DWORD (WINAPI * get_compressed_t)(const char *filename,
-                                              DWORD * high);
+                                              DWORD *high);
     get_compressed_t get_compressed;
     struct _stati64 st;
     const char *filename = bs->filename;
@@ -516,22 +516,22 @@ static QEMUOptionParameter raw_create_options[] = {
 };
 
 static BlockDriver bdrv_file = {
-    .format_name       = "file",
-    .protocol_name     = "file",
-    .instance_size     = sizeof(BDRVRawState),
+    .format_name    = "file",
+    .protocol_name  = "file",
+    .instance_size  = sizeof(BDRVRawState),
     .bdrv_needs_filename = true,
     .bdrv_parse_filename = raw_parse_filename,
-    .bdrv_file_open    = raw_open,
-    .bdrv_close                = raw_close,
-    .bdrv_create       = raw_create,
+    .bdrv_file_open = raw_open,
+    .bdrv_close     = raw_close,
+    .bdrv_create    = raw_create,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
 
     .bdrv_aio_readv     = raw_aio_readv,
     .bdrv_aio_writev    = raw_aio_writev,
     .bdrv_aio_flush     = raw_aio_flush,
 
-    .bdrv_truncate     = raw_truncate,
-    .bdrv_getlength    = raw_getlength,
+    .bdrv_truncate  = raw_truncate,
+    .bdrv_getlength = raw_getlength,
     .bdrv_get_allocated_file_size
                         = raw_get_allocated_file_size,
 
@@ -548,9 +548,9 @@ static int find_cdrom(char *cdrom_name, int cdrom_name_size)
 
     memset(drives, 0, sizeof(drives));
     GetLogicalDriveStrings(sizeof(drives), drives);
-    while(pdrv[0] != '\0') {
+    while (pdrv[0] != '\0') {
         type = GetDriveType(pdrv);
-        switch(type) {
+        switch (type) {
         case DRIVE_CDROM:
             snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]);
             return 0;
@@ -640,7 +640,8 @@ static int hdev_open(BlockDriverState *bs, QDict *options, 
int flags,
         if (((filename[0] >= 'a' && filename[0] <= 'z') ||
              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
             filename[1] == ':' && filename[2] == '\0') {
-            snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", 
filename[0]);
+            snprintf(device_name, sizeof(device_name),
+                     "\\\\.\\%c:", filename[0]);
             filename = device_name;
         }
     }
@@ -671,14 +672,14 @@ done:
 }
 
 static BlockDriver bdrv_host_device = {
-    .format_name       = "host_device",
-    .protocol_name     = "host_device",
-    .instance_size     = sizeof(BDRVRawState),
+    .format_name    = "host_device",
+    .protocol_name  = "host_device",
+    .instance_size  = sizeof(BDRVRawState),
     .bdrv_needs_filename = true,
     .bdrv_parse_filename = hdev_parse_filename,
-    .bdrv_probe_device = hdev_probe_device,
-    .bdrv_file_open    = hdev_open,
-    .bdrv_close                = raw_close,
+    .bdrv_probe_device  = hdev_probe_device,
+    .bdrv_file_open = hdev_open,
+    .bdrv_close     = raw_close,
 
     .bdrv_aio_readv     = raw_aio_readv,
     .bdrv_aio_writev    = raw_aio_writev,
diff --git a/block/ssh.c b/block/ssh.c
index aa63c9d..8dc4e80 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -191,7 +191,7 @@ static int parse_uri(const char *filename, QDict *options, 
Error **errp)
         goto err;
     }
 
-    if(uri->user && strcmp(uri->user, "") != 0) {
+    if (uri->user && strcmp(uri->user, "") != 0) {
         qdict_put(options, "user", qstring_from_str(uri->user));
     }
 
@@ -219,10 +219,10 @@ static int parse_uri(const char *filename, QDict 
*options, Error **errp)
 
  err:
     if (qp) {
-      query_params_free(qp);
+        query_params_free(qp);
     }
     if (uri) {
-      uri_free(uri);
+        uri_free(uri);
     }
     return -EINVAL;
 }
@@ -235,7 +235,8 @@ static void ssh_parse_filename(const char *filename, QDict 
*options,
         qdict_haskey(options, "port") ||
         qdict_haskey(options, "path") ||
         qdict_haskey(options, "host_key_check")) {
-        error_setg(errp, "user, host, port, path, host_key_check cannot be 
used at the same time as a file option");
+        error_setg(errp, "user, host, port, path, host_key_check cannot be "
+                   "used at the same time as a file option");
         return;
     }
 
@@ -289,8 +290,8 @@ static int check_host_key_knownhosts(BDRVSSHState *s,
         break;
     case LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
         ret = -EINVAL;
-        session_error_report(s, "host key does not match the one in 
known_hosts (found key %s)",
-                             found->key);
+        session_error_report(s, "host key does not match the one in "
+                             "known_hosts (found key %s)", found->key);
         goto out;
     case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
         ret = -EINVAL;
@@ -302,8 +303,8 @@ static int check_host_key_knownhosts(BDRVSSHState *s,
         goto out;
     default:
         ret = -EINVAL;
-        session_error_report(s, "unknown error matching the host key with 
known_hosts (%d)",
-                             r);
+        session_error_report(s, "unknown error matching the host key with "
+                             "known_hosts (%d)", r);
         goto out;
     }
 
@@ -368,7 +369,7 @@ check_host_key_hash(BDRVSSHState *s, const char *hash,
         return -EINVAL;
     }
 
-    if(compare_fingerprint((unsigned char *) fingerprint, fingerprint_len,
+    if (compare_fingerprint((unsigned char *) fingerprint, fingerprint_len,
                            hash) != 0) {
         error_report("remote host key does not match host_key_check '%s'",
                      hash);
@@ -418,7 +419,8 @@ static int authenticate(BDRVSSHState *s, const char *user)
     userauthlist = libssh2_userauth_list(s->session, user, strlen(user));
     if (strstr(userauthlist, "publickey") == NULL) {
         ret = -EPERM;
-        error_report("remote server does not support \"publickey\" 
authentication");
+        error_report("remote server does not support \"publickey\" "
+                     "authentication");
         goto out;
     }
 
@@ -440,7 +442,7 @@ static int authenticate(BDRVSSHState *s, const char *user)
         goto out;
     }
 
-    for(;;) {
+    for (;;) {
         r = libssh2_agent_get_identity(agent, &identity, prev_identity);
         if (r == 1) {           /* end of list */
             break;
@@ -1060,7 +1062,7 @@ static void bdrv_ssh_init(void)
 
     r = libssh2_init(0);
     if (r != 0) {
-        fprintf(stderr, "libssh2 initialization failed, %d\n", r);
+        error_report("libssh2 initialization failed, %d", r);
         exit(EXIT_FAILURE);
     }
 
diff --git a/block/vdi.c b/block/vdi.c
index 27737af..2883066 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -65,7 +65,7 @@ typedef unsigned char uuid_t[16];
 /* Code configuration options. */
 
 /* Enable debug messages. */
-//~ #define CONFIG_VDI_DEBUG
+/* ~ #define CONFIG_VDI_DEBUG */
 
 /* Support write operations on VDI images. */
 #define CONFIG_VDI_WRITE
@@ -305,21 +305,22 @@ static int vdi_check(BlockDriverState *bs, 
BdrvCheckResult *res,
                 if (!VDI_IS_ALLOCATED(bmap[bmap_entry])) {
                     bmap[bmap_entry] = bmap_entry;
                 } else {
-                    fprintf(stderr, "ERROR: block index %" PRIu32
-                            " also used by %" PRIu32 "\n", bmap[bmap_entry], 
bmap_entry);
+                    error_report("ERROR: block index %" PRIu32
+                                 " also used by %" PRIu32,
+                                 bmap[bmap_entry], bmap_entry);
                     res->corruptions++;
                 }
             } else {
-                fprintf(stderr, "ERROR: block index %" PRIu32
-                        " too large, is %" PRIu32 "\n", block, bmap_entry);
+                error_report("ERROR: block index %" PRIu32
+                             " too large, is %" PRIu32, block, bmap_entry);
                 res->corruptions++;
             }
         }
     }
     if (blocks_allocated != s->header.blocks_allocated) {
-        fprintf(stderr, "ERROR: allocated blocks mismatch, is %" PRIu32
-               ", should be %" PRIu32 "\n",
-               blocks_allocated, s->header.blocks_allocated);
+        error_report("ERROR: allocated blocks mismatch, is %" PRIu32
+                     ", should be %" PRIu32,
+                     blocks_allocated, s->header.blocks_allocated);
         res->corruptions++;
     }
 
@@ -730,7 +731,7 @@ static int vdi_create(const char *filename, 
QEMUOptionParameter *options,
     blocks = (bytes + block_size - 1) / block_size;
 
     bmap_size = blocks * sizeof(uint32_t);
-    bmap_size = ((bmap_size + SECTOR_SIZE - 1) & ~(SECTOR_SIZE -1));
+    bmap_size = ((bmap_size + SECTOR_SIZE - 1) & ~(SECTOR_SIZE - 1));
 
     memset(&header, 0, sizeof(header));
     pstrcpy(header.text, sizeof(header.text), VDI_TEXT);
diff --git a/block/vmdk.c b/block/vmdk.c
index 480ea37..35d7efd 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -630,8 +630,7 @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
             le32_to_cpu(footer.footer_marker.type) != MARKER_FOOTER ||
             le64_to_cpu(footer.eos_marker.val) != 0  ||
             le32_to_cpu(footer.eos_marker.size) != 0  ||
-            le32_to_cpu(footer.eos_marker.type) != MARKER_END_OF_STREAM)
-        {
+            le32_to_cpu(footer.eos_marker.type) != MARKER_END_OF_STREAM) {
             return -EINVAL;
         }
 
@@ -742,16 +741,16 @@ static int vmdk_open_sparse(BlockDriverState *bs,
 
     magic = ldl_be_p(buf);
     switch (magic) {
-        case VMDK3_MAGIC:
-            return vmdk_open_vmfs_sparse(bs, file, flags, errp);
-            break;
-        case VMDK4_MAGIC:
-            return vmdk_open_vmdk4(bs, file, flags, errp);
-            break;
-        default:
-            error_setg(errp, "Image not in VMDK format");
-            return -EINVAL;
-            break;
+    case VMDK3_MAGIC:
+        return vmdk_open_vmfs_sparse(bs, file, flags, errp);
+        break;
+    case VMDK4_MAGIC:
+        return vmdk_open_vmdk4(bs, file, flags, errp);
+        break;
+    default:
+        error_setg(errp, "Image not in VMDK format");
+        return -EINVAL;
+        break;
     }
 }
 
@@ -783,7 +782,7 @@ static int vmdk_parse_extents(const char *desc, 
BlockDriverState *bs,
             goto next_line;
         } else if (!strcmp(type, "FLAT")) {
             if (ret != 5 || flat_offset < 0) {
-                error_setg(errp, "Invalid extent lines: \n%s", p);
+                error_setg(errp, "Invalid extent lines:\n%s", p);
                 return -EINVAL;
             }
         } else if (!strcmp(type, "VMFS")) {
@@ -830,7 +829,8 @@ static int vmdk_parse_extents(const char *desc, 
BlockDriverState *bs,
             if (!buf) {
                 ret = -EINVAL;
             } else {
-                ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, buf, 
errp);
+                ret = vmdk_open_sparse(bs, extent_file, bs->open_flags,
+                                       buf, errp);
             }
             if (ret) {
                 g_free(buf);
@@ -899,14 +899,14 @@ static int vmdk_open(BlockDriverState *bs, QDict 
*options, int flags,
 
     magic = ldl_be_p(buf);
     switch (magic) {
-        case VMDK3_MAGIC:
-        case VMDK4_MAGIC:
-            ret = vmdk_open_sparse(bs, bs->file, flags, buf, errp);
-            s->desc_offset = 0x200;
-            break;
-        default:
-            ret = vmdk_open_desc_file(bs, flags, buf, errp);
-            break;
+    case VMDK3_MAGIC:
+    case VMDK4_MAGIC:
+        ret = vmdk_open_sparse(bs, bs->file, flags, buf, errp);
+        s->desc_offset = 0x200;
+        break;
+    default:
+        ret = vmdk_open_desc_file(bs, flags, buf, errp);
+        break;
     }
     if (ret) {
         goto fail;
@@ -2018,24 +2018,21 @@ static int vmdk_check(BlockDriverState *bs, 
BdrvCheckResult *result,
         }
         extent = find_extent(s, sector_num, extent);
         if (!extent) {
-            fprintf(stderr,
-                    "ERROR: could not find extent for sector %" PRId64 "\n",
-                    sector_num);
+            error_report("ERROR: could not find extent for sector %" PRId64,
+                         sector_num);
             break;
         }
         ret = get_cluster_offset(bs, extent, NULL,
                                  sector_num << BDRV_SECTOR_BITS,
                                  0, &cluster_offset);
         if (ret == VMDK_ERROR) {
-            fprintf(stderr,
-                    "ERROR: could not get cluster_offset for sector %"
-                    PRId64 "\n", sector_num);
+            error_report("ERROR: could not get cluster_offset for sector %"
+                         PRId64, sector_num);
             break;
         }
         if (ret == VMDK_OK && cluster_offset >= bdrv_getlength(extent->file)) {
-            fprintf(stderr,
-                    "ERROR: cluster offset for sector %"
-                    PRId64 " points after EOF\n", sector_num);
+            error_report("ERROR: cluster offset for sector %"
+                         PRId64 " points after EOF", sector_num);
             break;
         }
         sector_num += extent->cluster_sectors;
@@ -2123,7 +2120,8 @@ static QEMUOptionParameter vmdk_create_options[] = {
         .type = OPT_STRING,
         .help =
             "VMDK flat extent format, can be one of "
-            "{monolithicSparse (default) | monolithicFlat | 
twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
+            "{monolithicSparse (default) | monolithicFlat | "
+            "twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
     },
     {
         .name = BLOCK_OPT_ZEROED_GRAIN,
diff --git a/block/vpc.c b/block/vpc.c
index 2e25f57..e0bb333 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -138,7 +138,7 @@ typedef struct BDRVVPCState {
     Error *migration_blocker;
 } BDRVVPCState;
 
-static uint32_t vpc_checksum(uint8_t* buf, size_t size)
+static uint32_t vpc_checksum(uint8_t *buf, size_t size)
 {
     uint32_t res = 0;
     int i;
@@ -153,7 +153,7 @@ static uint32_t vpc_checksum(uint8_t* buf, size_t size)
 static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
 {
     if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
-       return 100;
+        return 100;
     return 0;
 }
 
@@ -203,8 +203,8 @@ static int vpc_open(BlockDriverState *bs, QDict *options, 
int flags,
     checksum = be32_to_cpu(footer->checksum);
     footer->checksum = 0;
     if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum)
-        fprintf(stderr, "block-vpc: The header checksum of '%s' is "
-            "incorrect.\n", bs->filename);
+        error_report("block-vpc: The header checksum of '%s' is "
+                     "incorrect.", bs->filename);
 
     /* Write 'checksum' back to footer, or else will leave it with zero. */
     footer->checksum = be32_to_cpu(checksum);
@@ -353,7 +353,8 @@ static inline int64_t get_sector_offset(BlockDriverState 
*bs,
     pagetable_index = offset / s->block_size;
     pageentry_index = (offset % s->block_size) / 512;
 
-    if (pagetable_index >= s->max_table_entries || 
s->pagetable[pagetable_index] == 0xffffffff)
+    if (pagetable_index >= s->max_table_entries ||
+        s->pagetable[pagetable_index] == 0xffffffff)
         return -1; // not allocated
 
     bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
@@ -413,7 +414,7 @@ static inline int64_t get_sector_offset(BlockDriverState 
*bs,
  *
  * Returns 0 on success and < 0 on error
  */
-static int rewrite_footer(BlockDriverState* bs)
+static int rewrite_footer(BlockDriverState *bs)
 {
     int ret;
     BDRVVPCState *s = bs->opaque;
@@ -433,7 +434,7 @@ static int rewrite_footer(BlockDriverState* bs)
  *
  * Returns the sectors' offset in the image file on success and < 0 on error
  */
-static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
+static int64_t alloc_block(BlockDriverState *bs, int64_t sector_num)
 {
     BDRVVPCState *s = bs->opaque;
     int64_t bat_offset;
@@ -605,8 +606,8 @@ static coroutine_fn int vpc_co_write(BlockDriverState *bs, 
int64_t sector_num,
  * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
  * and instead allow up to 255 heads.
  */
-static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
-    uint8_t* heads, uint8_t* secs_per_cyl)
+static int calculate_geometry(int64_t total_sectors, uint16_t *cyls,
+    uint8_t *heads, uint8_t *secs_per_cyl)
 {
     uint32_t cyls_times_heads;
 
@@ -783,8 +784,7 @@ static int vpc_create(const char *filename, 
QEMUOptionParameter *options,
     total_sectors = total_size / BDRV_SECTOR_SIZE;
     for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
         if (calculate_geometry(total_sectors + i, &cyls, &heads,
-                               &secs_per_cyl))
-        {
+                               &secs_per_cyl)) {
             ret = -EFBIG;
             goto fail;
         }
diff --git a/block/vvfat.c b/block/vvfat.c
index c3af7ff..63a69b1 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -54,17 +54,18 @@
 
 #undef stderr
 #define stderr STDERR
-FILE* stderr = NULL;
+FILE *stderr = NULL;
 
 static void checkpoint(void);
 
 #ifdef __MINGW32__
-void nonono(const char* file, int line, const char* msg) {
+void nonono(const char *file, int line, const char *msg)
+{
     fprintf(stderr, "Nonono! %s:%d %s\n", file, line, msg);
     exit(-5);
 }
 #undef assert
-#define assert(a) do {if (!(a)) nonono(__FILE__, __LINE__, #a);}while(0)
+#define assert(a) do {if (!(a)) nonono(__FILE__, __LINE__, #a); } while (0)
 #endif
 
 #else
@@ -75,22 +76,22 @@ void nonono(const char* file, int line, const char* msg) {
 
 /* dynamic array functions */
 typedef struct array_t {
-    char* pointer;
-    unsigned int size,next,item_size;
+    char *pointer;
+    unsigned int size, next, item_size;
 } array_t;
 
-static inline void array_init(array_t* array,unsigned int item_size)
+static inline void array_init(array_t *array, unsigned int item_size)
 {
     array->pointer = NULL;
-    array->size=0;
-    array->next=0;
-    array->item_size=item_size;
+    array->size = 0;
+    array->next = 0;
+    array->item_size = item_size;
 }
 
-static inline void array_free(array_t* array)
+static inline void array_free(array_t *array)
 {
     g_free(array->pointer);
-    array->size=array->next=0;
+    array->size=array->next = 0;
 }
 
 /* does not automatically grow */
@@ -743,38 +744,38 @@ static int read_directory(BDRVVVFATState* s, int 
mapping_index)
        /* create directory entry for this file */
        direntry=create_short_and_long_name(s, i, entry->d_name,
                is_dot || is_dotdot);
-       direntry->attributes=(S_ISDIR(st.st_mode)?0x10:0x20);
-       direntry->reserved[0]=direntry->reserved[1]=0;
-       direntry->ctime=fat_datetime(st.st_ctime,1);
-       direntry->cdate=fat_datetime(st.st_ctime,0);
-       direntry->adate=fat_datetime(st.st_atime,0);
-       direntry->begin_hi=0;
-       direntry->mtime=fat_datetime(st.st_mtime,1);
-       direntry->mdate=fat_datetime(st.st_mtime,0);
+       direntry->attributes = (S_ISDIR(st.st_mode)?0x10:0x20);
+       direntry->reserved[0] = direntry->reserved[1]=0;
+       direntry->ctime = fat_datetime(st.st_ctime, 1);
+       direntry->cdate = fat_datetime(st.st_ctime, 0);
+       direntry->adate = fat_datetime(st.st_atime, 0);
+       direntry->begin_hi = 0;
+       direntry->mtime = fat_datetime(st.st_mtime, 1);
+       direntry->mdate = fat_datetime(st.st_mtime, 0);
        if(is_dotdot)
            set_begin_of_direntry(direntry, first_cluster_of_parent);
        else if(is_dot)
            set_begin_of_direntry(direntry, first_cluster);
        else
-           direntry->begin=0; /* do that later */
+           direntry->begin = 0; /* do that later */
         if (st.st_size > 0x7fffffff) {
-           fprintf(stderr, "File %s is larger than 2GB\n", buffer);
+               error_report("File %s is larger than 2GB", buffer);
             g_free(buffer);
             closedir(dir);
            return -2;
         }
-       direntry->size=cpu_to_le32(S_ISDIR(st.st_mode)?0:st.st_size);
+       direntry->size = cpu_to_le32(S_ISDIR(st.st_mode)?0:st.st_size);
 
        /* create mapping for this file */
        if(!is_dot && !is_dotdot && (S_ISDIR(st.st_mode) || st.st_size)) {
-           s->current_mapping=(mapping_t*)array_get_next(&(s->mapping));
+           s->current_mapping = (mapping_t*)array_get_next(&(s->mapping));
            s->current_mapping->begin=0;
            s->current_mapping->end=st.st_size;
            /*
             * we get the direntry of the most recent direntry, which
             * contains the short name and all the relevant information.
             */
-           s->current_mapping->dir_index=s->directory.next-1;
+           s->current_mapping->dir_index = s->directory.next-1;
            s->current_mapping->first_mapping_index = -1;
            if (S_ISDIR(st.st_mode)) {
                s->current_mapping->mode = MODE_DIRECTORY;
@@ -784,7 +785,7 @@ static int read_directory(BDRVVVFATState* s, int 
mapping_index)
                s->current_mapping->mode = MODE_UNDEFINED;
                s->current_mapping->info.file.offset = 0;
            }
-           s->current_mapping->path=buffer;
+           s->current_mapping->path = buffer;
            s->current_mapping->read_only =
                (st.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0;
        }
@@ -793,7 +794,7 @@ static int read_directory(BDRVVVFATState* s, int 
mapping_index)
 
     /* fill with zeroes up to the end of the cluster */
     while(s->directory.next%(0x10*s->sectors_per_cluster)) {
-       direntry_t* direntry=array_get_next(&(s->directory));
+       direntry_t* direntry = array_get_next(&(s->directory));
        memset(direntry,0,sizeof(direntry_t));
     }
 
@@ -892,9 +893,8 @@ static int init_directories(BDRVVVFATState* s,
         if (mapping->mode & MODE_DIRECTORY) {
            mapping->begin = cluster;
            if(read_directory(s, i)) {
-               fprintf(stderr, "Could not read directory %s\n",
-                       mapping->path);
-               return -1;
+                 error_report("Could not read directory %s", mapping->path);
+                 return -1;
            }
            mapping = array_get(&(s->mapping), i);
        } else {
@@ -919,8 +919,8 @@ static int init_directories(BDRVVVFATState* s,
        cluster = mapping->end;
 
        if(cluster > s->cluster_count) {
-           fprintf(stderr,"Directory does not fit in FAT%d (capacity %.2f 
MB)\n",
-                   s->fat_type, s->sector_count / 2000.0);
+           error_report("Directory does not fit in FAT%d (capacity %.2f MB)",
+                            s->fat_type, s->sector_count / 2000.0);
            return -EINVAL;
        }
 
@@ -1127,8 +1127,8 @@ DLOG(if (stderr == NULL) {
 
     switch (s->fat_type) {
     case 32:
-           fprintf(stderr, "Big fat greek warning: FAT32 has not been tested. "
-                "You are welcome to do so!\n");
+           error_report("Big fat greek warning: FAT32 has not been tested. "
+                     "You are welcome to do so!");
         break;
     case 16:
     case 12:
@@ -1154,8 +1154,8 @@ DLOG(if (stderr == NULL) {
     s->fat2 = NULL;
     s->downcase_short_names = 1;
 
-    fprintf(stderr, "vvfat %s chs %d,%d,%d\n",
-            dirname, cyls, heads, secs);
+    error_report("vvfat %s chs %d,%d,%d",
+                 dirname, cyls, heads, secs);
 
     s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);
 
@@ -1863,16 +1863,17 @@ static int check_directory_consistency(BDRVVVFATState 
*s,
        ret++;
 
        if (s->used_clusters[cluster_num] & USED_ANY) {
-           fprintf(stderr, "cluster %d used more than once\n", 
(int)cluster_num);
+           error_report("cluster %d used more than once", (int)cluster_num);
            return 0;
        }
        s->used_clusters[cluster_num] = USED_DIRECTORY;
 
-DLOG(fprintf(stderr, "read cluster %d (sector %d)\n", (int)cluster_num, 
(int)cluster2sector(s, cluster_num)));
+DLOG(fprintf(stderr, "read cluster %d (sector %d)\n", (int)cluster_num,
+     (int)cluster2sector(s, cluster_num)));
        subret = vvfat_read(s->bs, cluster2sector(s, cluster_num), cluster,
                s->sectors_per_cluster);
        if (subret) {
-           fprintf(stderr, "Error fetching direntries\n");
+           error_report("Error fetching direntries");
        fail:
             g_free(cluster);
            return 0;
@@ -1888,8 +1889,8 @@ DLOG(fprintf(stderr, "check direntry %d:\n", i); 
print_direntry(direntries + i))
 
            subret = parse_long_name(&lfn, direntries + i);
            if (subret < 0) {
-               fprintf(stderr, "Error in long name\n");
-               goto fail;
+               error_report("Error in long name");
+               goto fail;
            }
            if (subret == 0 || is_free(direntries + i))
                continue;
@@ -1897,7 +1898,7 @@ DLOG(fprintf(stderr, "check direntry %d:\n", i); 
print_direntry(direntries + i))
            if (fat_chksum(direntries+i) != lfn.checksum) {
                subret = parse_short_name(s, &lfn, direntries + i);
                if (subret < 0) {
-                   fprintf(stderr, "Error in short name (%d)\n", subret);
+                   error_report("Error in short name (%d)", subret);
                    goto fail;
                }
                if (subret > 0 || !strcmp((char*)lfn.name, ".")
@@ -1907,8 +1908,8 @@ DLOG(fprintf(stderr, "check direntry %d:\n", i); 
print_direntry(direntries + i))
            lfn.checksum = 0x100; /* cannot use long name twice */
 
            if (path_len + 1 + lfn.len >= PATH_MAX) {
-               fprintf(stderr, "Name too long: %s/%s\n", path, lfn.name);
-               goto fail;
+               error_report("Name too long: %s/%s", path, lfn.name);
+               goto fail;
            }
             pstrcpy(path2 + path_len + 1, sizeof(path2) - path_len - 1,
                     (char*)lfn.name);
@@ -1967,15 +1968,15 @@ DLOG(checkpoint());
      * - if all is fine, return number of used clusters
      */
     if (s->fat2 == NULL) {
-       int size = 0x200 * s->sectors_per_fat;
-       s->fat2 = g_malloc(size);
-       memcpy(s->fat2, s->fat.pointer, size);
+        int size = 0x200 * s->sectors_per_fat;
+        s->fat2 = g_malloc(size);
+        memcpy(s->fat2, s->fat.pointer, size);
     }
     check = vvfat_read(s->bs,
            s->first_sectors_number, s->fat2, s->sectors_per_fat);
     if (check) {
-       fprintf(stderr, "Could not copy fat\n");
-       return 0;
+       error_report("Could not copy fat");
+       return 0;
     }
     assert (s->used_clusters);
     for (i = 0; i < sector2cluster(s, s->sector_count); i++)
@@ -1987,15 +1988,15 @@ DLOG(checkpoint());
      * (check_directory_consistency() will unmark those still present). */
     if (s->qcow)
        for (i = 0; i < s->mapping.next; i++) {
-           mapping_t* mapping = array_get(&(s->mapping), i);
-           if (mapping->first_mapping_index < 0)
-               mapping->mode |= MODE_DELETED;
+        mapping_t* mapping = array_get(&(s->mapping), i);
+        if (mapping->first_mapping_index < 0)
+       mapping->mode |= MODE_DELETED;
        }
 
     used_clusters_count = check_directory_consistency(s, 0, s->path);
     if (used_clusters_count <= 0) {
-       DLOG(fprintf(stderr, "problem in directory\n"));
-       return 0;
+        DLOG(fprintf(stderr, "problem in directory\n"));
+        return 0;
     }
 
     check = s->last_cluster_of_root_directory;
@@ -2323,8 +2324,8 @@ static int commit_one_file(BDRVVVFATState* s,
 
     fd = qemu_open(mapping->path, O_RDWR | O_CREAT | O_BINARY, 0666);
     if (fd < 0) {
-       fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
-               strerror(errno), errno);
+          error_report("Could not open %s... (%s, %d)", mapping->path,
+                       strerror(errno), errno);
         g_free(cluster);
        return fd;
     }
@@ -2716,8 +2717,8 @@ static int do_commit(BDRVVVFATState* s)
 
     ret = handle_renames_and_mkdirs(s);
     if (ret) {
-       fprintf(stderr, "Error handling renames (%d)\n", ret);
-        abort();
+          error_report("Error handling renames (%d)", ret);
+       abort();
        return ret;
     }
 
@@ -2727,22 +2728,22 @@ static int do_commit(BDRVVVFATState* s)
     /* recurse direntries from root (using bs->bdrv_read) */
     ret = commit_direntries(s, 0, -1);
     if (ret) {
-       fprintf(stderr, "Fatal: error while committing (%d)\n", ret);
-        abort();
+          error_report("Fatal: error while committing (%d)", ret);
+       abort();
        return ret;
     }
 
     ret = handle_commits(s);
     if (ret) {
-       fprintf(stderr, "Error handling commits (%d)\n", ret);
-        abort();
+          error_report("Error handling commits (%d)", ret);
+       abort();
        return ret;
     }
 
     ret = handle_deletes(s);
     if (ret) {
-       fprintf(stderr, "Error deleting\n");
-        abort();
+          error_report("Error deleting");
+       abort();
        return ret;
     }
 
@@ -2794,9 +2795,9 @@ DLOG(checkpoint());
        mapping_t* mapping = find_mapping_for_cluster(s, i);
        if (mapping) {
            if (mapping->read_only) {
-               fprintf(stderr, "Tried to write to write-protected file %s\n",
-                       mapping->path);
-               return -1;
+                 error_report("Tried to write to write-protected file %s",
+                              mapping->path);
+                 return -1;
            }
 
            if (mapping->mode & MODE_DIRECTORY) {
@@ -2819,8 +2820,8 @@ DLOG(checkpoint());
                for (k = 0; k < (end - begin) * 0x10; k++) {
                    /* do not allow non-ASCII filenames */
                    if (parse_long_name(&lfn, direntries + k) < 0) {
-                       fprintf(stderr, "Warning: non-ASCII filename\n");
-                       return -1;
+                            error_report("Warning: non-ASCII filename");
+                            return -1;
                    }
                    /* no access to the direntry of a read-only file */
                    else if (is_short_name(direntries+k) &&
@@ -2828,7 +2829,7 @@ DLOG(checkpoint());
                        if (memcmp(direntries + k,
                                    array_get(&(s->directory), dir_index + k),
                                    sizeof(direntry_t))) {
-                           fprintf(stderr, "Warning: tried to write to 
write-protected file\n");
+                           error_report("Warning: tried to write to 
write-protected file");
                            return -1;
                        }
                    }
@@ -2845,8 +2846,8 @@ DLOG(checkpoint());
 DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, 
nb_sectors));
     ret = bdrv_write(s->qcow, sector_num, buf, nb_sectors);
     if (ret < 0) {
-       fprintf(stderr, "Error writing to qcow backend\n");
-       return ret;
+          error_report("Error writing to qcow backend");
+          return ret;
     }
 
     for (i = sector2cluster(s, sector_num);
diff --git a/blockdev.c b/blockdev.c
index 7810e9f..2c6f559 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -158,8 +158,8 @@ DriveInfo *drive_get(BlockInterfaceType type, int bus, int 
unit)
 
     QTAILQ_FOREACH(dinfo, &drives, next) {
         if (dinfo->type == type &&
-           dinfo->bus == bus &&
-           dinfo->unit == unit)
+            dinfo->bus == bus &&
+            dinfo->unit == unit)
             return dinfo;
     }
 
@@ -180,8 +180,8 @@ int drive_get_max_bus(BlockInterfaceType type)
 
     max_bus = -1;
     QTAILQ_FOREACH(dinfo, &drives, next) {
-        if(dinfo->type == type &&
-           dinfo->bus > max_bus)
+        if (dinfo->type == type &&
+            dinfo->bus > max_bus)
             max_bus = dinfo->bus;
     }
     return max_bus;
@@ -698,9 +698,9 @@ DriveInfo *drive_init(QemuOpts *all_opts, 
BlockInterfaceType block_default_type)
 
     /* Deprecated option boot=[on|off] */
     if (qemu_opt_get(legacy_opts, "boot") != NULL) {
-        fprintf(stderr, "qemu-kvm: boot=on|off is deprecated and will be "
-                "ignored. Future versions will reject this parameter. Please "
-                "update your scripts.\n");
+        error_report("qemu-kvm: boot=on|off is deprecated and will be "
+                     "ignored. Future versions will reject this parameter. "
+                     "Please update your scripts.");
     }
 
     /* Media type */
@@ -729,7 +729,7 @@ DriveInfo *drive_init(QemuOpts *all_opts, 
BlockInterfaceType block_default_type)
     qdict_put(bs_opts, "read-only",
               qstring_from_str(read_only ? "on" : "off"));
     qdict_put(bs_opts, "copy-on-read",
-              qstring_from_str(copy_on_read ? "on" :"off"));
+              qstring_from_str(copy_on_read ? "on" : "off"));
 
     /* Controller type */
     value = qemu_opt_get(legacy_opts, "if");
@@ -815,14 +815,14 @@ DriveInfo *drive_init(QemuOpts *all_opts, 
BlockInterfaceType block_default_type)
     }
 
     if (unit_id == -1) {
-       unit_id = 0;
-       while (drive_get(type, bus_id, unit_id) != NULL) {
+        unit_id = 0;
+        while (drive_get(type, bus_id, unit_id) != NULL) {
            unit_id++;
            if (max_devs && unit_id >= max_devs) {
                unit_id -= max_devs;
                bus_id++;
            }
-       }
+        }
     }
 
     if (max_devs && unit_id >= max_devs) {
@@ -925,7 +925,7 @@ DriveInfo *drive_init(QemuOpts *all_opts, 
BlockInterfaceType block_default_type)
     dinfo->unit = unit_id;
     dinfo->devaddr = devaddr;
 
-    switch(type) {
+    switch (type) {
     case IF_IDE:
     case IF_SCSI:
     case IF_XEN:
@@ -2139,8 +2139,7 @@ void qmp_drive_mirror(const char *device, const char 
*target,
     }
 
     if ((sync == MIRROR_SYNC_MODE_FULL || !source)
-        && mode != NEW_IMAGE_MODE_EXISTING)
-    {
+        && mode != NEW_IMAGE_MODE_EXISTING) {
         /* create new image w/o backing file */
         assert(format && drv);
         bdrv_img_create(target, format,
-- 
1.7.9.5




reply via email to

[Prev in Thread] Current Thread [Next in Thread]